From 525c260303268a83da4c3413b953d13c9084e834 Mon Sep 17 00:00:00 2001 From: The Android Open Source Project Date: Thu, 13 Dec 2012 16:24:26 -0800 Subject: Snapshot 1a6bcf3cca90fedfbad33c1cdd6d05af5774fc01 Change-Id: I3ccb25bf7cde2c22f52260cae0e9957517e6bb5f --- Android.mk | 35 +- AndroidManifest.xml | 6 +- nci/Android.mk | 3 + nci/jni/Android.mk | 54 + nci/jni/CondVar.cpp | 145 ++ nci/jni/CondVar.h | 91 + nci/jni/DataQueue.cpp | 155 ++ nci/jni/DataQueue.h | 106 + nci/jni/HostAidRouter.cpp | 291 +++ nci/jni/HostAidRouter.h | 156 ++ nci/jni/IntervalTimer.cpp | 99 + nci/jni/IntervalTimer.h | 38 + nci/jni/JavaClassConstants.h | 37 + nci/jni/Mutex.cpp | 136 ++ nci/jni/Mutex.h | 113 + nci/jni/NativeLlcpConnectionlessSocket.cpp | 311 +++ nci/jni/NativeLlcpServiceSocket.cpp | 158 ++ nci/jni/NativeLlcpSocket.cpp | 271 +++ nci/jni/NativeNfcManager.cpp | 1816 ++++++++++++++++ nci/jni/NativeNfcTag.cpp | 1507 ++++++++++++++ nci/jni/NativeP2pDevice.cpp | 93 + nci/jni/NativeSecureElement.cpp | 245 +++ nci/jni/NfcJniUtil.cpp | 150 ++ nci/jni/NfcJniUtil.h | 152 ++ nci/jni/NfcTag.cpp | 1325 ++++++++++++ nci/jni/NfcTag.h | 419 ++++ nci/jni/PeerToPeer.cpp | 1840 ++++++++++++++++ nci/jni/PeerToPeer.h | 779 +++++++ nci/jni/Pn544Interop.cpp | 153 ++ nci/jni/Pn544Interop.h | 64 + nci/jni/PowerSwitch.cpp | 439 ++++ nci/jni/PowerSwitch.h | 258 +++ nci/jni/RouteDataSet.cpp | 555 +++++ nci/jni/RouteDataSet.h | 308 +++ nci/jni/SecureElement.cpp | 2189 ++++++++++++++++++++ nci/jni/SecureElement.h | 607 ++++++ nci/jni/SyncEvent.h | 171 ++ .../nfc/dhimpl/NativeLlcpConnectionlessSocket.java | 78 + .../nfc/dhimpl/NativeLlcpServiceSocket.java | 53 + .../com/android/nfc/dhimpl/NativeLlcpSocket.java | 99 + .../com/android/nfc/dhimpl/NativeNfcManager.java | 378 ++++ .../android/nfc/dhimpl/NativeNfcSecureElement.java | 67 + nci/src/com/android/nfc/dhimpl/NativeNfcTag.java | 811 ++++++++ .../com/android/nfc/dhimpl/NativeP2pDevice.java | 77 + .../com/android/nfc/dhimpl/NativeNfcManager.java | 46 + nxp/src/com/android/nfc/dhimpl/NativeNfcTag.java | 5 + src/com/android/nfc/DeviceHost.java | 20 + src/com/android/nfc/FireflyRenderer.java | 1 + src/com/android/nfc/NfcApplication.java | 24 + src/com/android/nfc/NfcDispatcher.java | 42 +- src/com/android/nfc/NfcRootActivity.java | 4 +- src/com/android/nfc/NfcService.java | 401 ++-- src/com/android/nfc/P2pLinkManager.java | 18 +- src/com/android/nfc/RegisteredComponentCache.java | 31 +- src/com/android/nfc/SendUi.java | 20 +- .../nfc/handover/BluetoothHeadsetHandover.java | 231 ++- src/com/android/nfc/handover/HandoverManager.java | 55 +- src/com/android/nfc/ndefpush/NdefPushServer.java | 67 +- src/com/android/nfc/snep/SnepClient.java | 24 +- src/com/android/nfc/snep/SnepServer.java | 22 +- 60 files changed, 17536 insertions(+), 313 deletions(-) create mode 100644 nci/Android.mk create mode 100644 nci/jni/Android.mk create mode 100644 nci/jni/CondVar.cpp create mode 100644 nci/jni/CondVar.h create mode 100644 nci/jni/DataQueue.cpp create mode 100644 nci/jni/DataQueue.h create mode 100644 nci/jni/HostAidRouter.cpp create mode 100644 nci/jni/HostAidRouter.h create mode 100644 nci/jni/IntervalTimer.cpp create mode 100644 nci/jni/IntervalTimer.h create mode 100644 nci/jni/JavaClassConstants.h create mode 100644 nci/jni/Mutex.cpp create mode 100644 nci/jni/Mutex.h create mode 100644 nci/jni/NativeLlcpConnectionlessSocket.cpp create mode 100644 nci/jni/NativeLlcpServiceSocket.cpp create mode 100644 nci/jni/NativeLlcpSocket.cpp create mode 100755 nci/jni/NativeNfcManager.cpp create mode 100755 nci/jni/NativeNfcTag.cpp create mode 100644 nci/jni/NativeP2pDevice.cpp create mode 100755 nci/jni/NativeSecureElement.cpp create mode 100755 nci/jni/NfcJniUtil.cpp create mode 100755 nci/jni/NfcJniUtil.h create mode 100755 nci/jni/NfcTag.cpp create mode 100755 nci/jni/NfcTag.h create mode 100644 nci/jni/PeerToPeer.cpp create mode 100644 nci/jni/PeerToPeer.h create mode 100644 nci/jni/Pn544Interop.cpp create mode 100644 nci/jni/Pn544Interop.h create mode 100755 nci/jni/PowerSwitch.cpp create mode 100755 nci/jni/PowerSwitch.h create mode 100644 nci/jni/RouteDataSet.cpp create mode 100644 nci/jni/RouteDataSet.h create mode 100755 nci/jni/SecureElement.cpp create mode 100755 nci/jni/SecureElement.h create mode 100644 nci/jni/SyncEvent.h create mode 100755 nci/src/com/android/nfc/dhimpl/NativeLlcpConnectionlessSocket.java create mode 100755 nci/src/com/android/nfc/dhimpl/NativeLlcpServiceSocket.java create mode 100755 nci/src/com/android/nfc/dhimpl/NativeLlcpSocket.java create mode 100755 nci/src/com/android/nfc/dhimpl/NativeNfcManager.java create mode 100755 nci/src/com/android/nfc/dhimpl/NativeNfcSecureElement.java create mode 100755 nci/src/com/android/nfc/dhimpl/NativeNfcTag.java create mode 100755 nci/src/com/android/nfc/dhimpl/NativeP2pDevice.java create mode 100644 src/com/android/nfc/NfcApplication.java diff --git a/Android.mk b/Android.mk index 2cdfc68..9aa7ee2 100644 --- a/Android.mk +++ b/Android.mk @@ -1,4 +1,8 @@ LOCAL_PATH:= $(call my-dir) + +######################################## +# NXP Configuration +######################################## include $(CLEAR_VARS) LOCAL_MODULE_TAGS := optional @@ -6,13 +10,8 @@ LOCAL_MODULE_TAGS := optional LOCAL_SRC_FILES := \ $(call all-java-files-under, src) -ifeq ($(NFC_USE_NCI_STACK), true) - LOCAL_SRC_FILES += \ - $(call all-java-files-under, nci) -else - LOCAL_SRC_FILES += \ +LOCAL_SRC_FILES += \ $(call all-java-files-under, nxp) -endif LOCAL_PACKAGE_NAME := Nfc LOCAL_CERTIFICATE := platform @@ -25,6 +24,30 @@ LOCAL_PROGUARD_ENABLED := disabled include $(BUILD_PACKAGE) +######################################## +# NCI Configuration +######################################## +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES := \ + $(call all-java-files-under, src) + +LOCAL_SRC_FILES += \ + $(call all-java-files-under, nci) + +LOCAL_PACKAGE_NAME := NfcNci +LOCAL_OVERRIDES_PACKAGES := Nfc +LOCAL_CERTIFICATE := platform + +LOCAL_STATIC_JAVA_LIBRARIES := NfcLogTags + +LOCAL_JNI_SHARED_LIBRARIES := libnfc_nci_jni + +LOCAL_PROGUARD_ENABLED := disabled + +include $(BUILD_PACKAGE) ##### # static lib for the log tags diff --git a/AndroidManifest.xml b/AndroidManifest.xml index f0c027f..710e2ee 100755 --- a/AndroidManifest.xml +++ b/AndroidManifest.xml @@ -20,10 +20,12 @@ + + + - - + + +/******************************************************************************* +** +** Function: CondVar +** +** Description: Initialize member variables. +** +** Returns: None. +** +*******************************************************************************/ +CondVar::CondVar () +{ + memset (&mCondition, 0, sizeof(mCondition)); + int const res = pthread_cond_init (&mCondition, NULL); + if (res) + { + ALOGE ("CondVar::CondVar: fail init; error=0x%X", res); + } +} + + +/******************************************************************************* +** +** Function: ~CondVar +** +** Description: Cleanup all resources. +** +** Returns: None. +** +*******************************************************************************/ +CondVar::~CondVar () +{ + int const res = pthread_cond_destroy (&mCondition); + if (res) + { + ALOGE ("CondVar::~CondVar: fail destroy; error=0x%X", res); + } +} + + +/******************************************************************************* +** +** Function: wait +** +** Description: Block the caller and wait for a condition. +** +** Returns: None. +** +*******************************************************************************/ +void CondVar::wait (Mutex& mutex) +{ + int const res = pthread_cond_wait (&mCondition, mutex.nativeHandle()); + if (res) + { + ALOGE ("CondVar::wait: fail wait; error=0x%X", res); + } +} + + +/******************************************************************************* +** +** Function: wait +** +** Description: Block the caller and wait for a condition. +** millisec: Timeout in milliseconds. +** +** Returns: True if wait is successful; false if timeout occurs. +** +*******************************************************************************/ +bool CondVar::wait (Mutex& mutex, long millisec) +{ + bool retVal = false; + struct timespec absoluteTime; + + if (clock_gettime (CLOCK_MONOTONIC, &absoluteTime) == -1) + { + ALOGE ("CondVar::wait: fail get time; errno=0x%X", errno); + } + else + { + absoluteTime.tv_sec += millisec / 1000; + long ns = absoluteTime.tv_nsec + ((millisec % 1000) * 1000000); + if (ns > 1000000000) + { + absoluteTime.tv_sec++; + absoluteTime.tv_nsec = ns - 1000000000; + } + else + absoluteTime.tv_nsec = ns; + } + + //pthread_cond_timedwait_monotonic_np() is an Android-specific function + //declared in /development/ndk/platforms/android-9/include/pthread.h; + //it uses monotonic clock. + //the standard pthread_cond_timedwait() uses realtime clock. + int waitResult = pthread_cond_timedwait_monotonic_np (&mCondition, mutex.nativeHandle(), &absoluteTime); + if ((waitResult != 0) && (waitResult != ETIMEDOUT)) + ALOGE ("CondVar::wait: fail timed wait; error=0x%X", waitResult); + retVal = (waitResult == 0); //waited successfully + return retVal; +} + + +/******************************************************************************* +** +** Function: notifyOne +** +** Description: Unblock the waiting thread. +** +** Returns: None. +** +*******************************************************************************/ +void CondVar::notifyOne () +{ + int const res = pthread_cond_signal (&mCondition); + if (res) + { + ALOGE ("CondVar::notifyOne: fail signal; error=0x%X", res); + } +} + diff --git a/nci/jni/CondVar.h b/nci/jni/CondVar.h new file mode 100644 index 0000000..c286d5c --- /dev/null +++ b/nci/jni/CondVar.h @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Encapsulate a condition variable for thread synchronization. + */ + +#pragma once +#include +#include "Mutex.h" + + +class CondVar +{ +public: + /******************************************************************************* + ** + ** Function: CondVar + ** + ** Description: Initialize member variables. + ** + ** Returns: None. + ** + *******************************************************************************/ + CondVar (); + + + /******************************************************************************* + ** + ** Function: ~CondVar + ** + ** Description: Cleanup all resources. + ** + ** Returns: None. + ** + *******************************************************************************/ + ~CondVar (); + + + /******************************************************************************* + ** + ** Function: wait + ** + ** Description: Block the caller and wait for a condition. + ** + ** Returns: None. + ** + *******************************************************************************/ + void wait (Mutex& mutex); + + + /******************************************************************************* + ** + ** Function: wait + ** + ** Description: Block the caller and wait for a condition. + ** millisec: Timeout in milliseconds. + ** + ** Returns: True if wait is successful; false if timeout occurs. + ** + *******************************************************************************/ + bool wait (Mutex& mutex, long millisec); + + + /******************************************************************************* + ** + ** Function: notifyOne + ** + ** Description: Unblock the waiting thread. + ** + ** Returns: None. + ** + *******************************************************************************/ + void notifyOne (); + +private: + pthread_cond_t mCondition; +}; diff --git a/nci/jni/DataQueue.cpp b/nci/jni/DataQueue.cpp new file mode 100644 index 0000000..caa2575 --- /dev/null +++ b/nci/jni/DataQueue.cpp @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Store data bytes in a variable-size queue. + */ + +#include "DataQueue.h" + + +/******************************************************************************* +** +** Function: DataQueue +** +** Description: Initialize member variables. +** +** Returns: None. +** +*******************************************************************************/ +DataQueue::DataQueue () +{ +} + + +/******************************************************************************* +** +** Function: ~DataQueue +** +** Description: Release all resources. +** +** Returns: None. +** +*******************************************************************************/ +DataQueue::~DataQueue () +{ + mMutex.lock (); + while (mQueue.empty() == false) + { + tHeader* header = mQueue.front (); + mQueue.pop_front (); + free (header); + } + mMutex.unlock (); +} + + +bool DataQueue::isEmpty() +{ + mMutex.lock (); + bool retval = mQueue.empty(); + mMutex.unlock (); + return retval; +} + + +/******************************************************************************* +** +** Function: enqueue +** +** Description: Append data to the queue. +** data: array of bytes +** dataLen: length of the data. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool DataQueue::enqueue (UINT8* data, UINT16 dataLen) +{ + if ((data == NULL) || (dataLen==0)) + return false; + + mMutex.lock (); + + bool retval = false; + tHeader* header = (tHeader*) malloc (sizeof(tHeader) + dataLen); + + if (header) + { + memset (header, 0, sizeof(tHeader)); + header->mDataLen = dataLen; + memcpy (header+1, data, dataLen); + + mQueue.push_back (header); + + retval = true; + } + else + { + ALOGE ("DataQueue::enqueue: out of memory ?????"); + } + mMutex.unlock (); + return retval; +} + + +/******************************************************************************* +** +** Function: dequeue +** +** Description: Retrieve and remove data from the front of the queue. +** buffer: array to store the data. +** bufferMaxLen: maximum size of the buffer. +** actualLen: actual length of the data. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool DataQueue::dequeue (UINT8* buffer, UINT16 bufferMaxLen, UINT16& actualLen) +{ + mMutex.lock (); + + tHeader* header = mQueue.front (); + bool retval = false; + + if (header && buffer && (bufferMaxLen>0)) + { + if (header->mDataLen <= bufferMaxLen) + { + //caller's buffer is big enough to store all data + actualLen = header->mDataLen; + char* src = (char*)(header) + sizeof(tHeader) + header->mOffset; + memcpy (buffer, src, actualLen); + + mQueue.pop_front (); + free (header); + } + else + { + //caller's buffer is too small + actualLen = bufferMaxLen; + char* src = (char*)(header) + sizeof(tHeader) + header->mOffset; + memcpy (buffer, src, actualLen); + //adjust offset so the next dequeue() will get the remainder + header->mDataLen -= actualLen; + header->mOffset += actualLen; + } + retval = true; + } + mMutex.unlock (); + return retval; +} + diff --git a/nci/jni/DataQueue.h b/nci/jni/DataQueue.h new file mode 100644 index 0000000..bfd415c --- /dev/null +++ b/nci/jni/DataQueue.h @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Store data bytes in a variable-size queue. + */ + +#pragma once +#include "NfcJniUtil.h" +#include "gki.h" +#include "Mutex.h" +#include + + +class DataQueue +{ +public: + /******************************************************************************* + ** + ** Function: DataQueue + ** + ** Description: Initialize member variables. + ** + ** Returns: None. + ** + *******************************************************************************/ + DataQueue (); + + + /******************************************************************************* + ** + ** Function: ~DataQueue + ** + ** Description: Release all resources. + ** + ** Returns: None. + ** + *******************************************************************************/ + ~DataQueue (); + + + /******************************************************************************* + ** + ** Function: enqueue + ** + ** Description: Append data to the queue. + ** data: array of bytes + ** dataLen: length of the data. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool enqueue (UINT8* data, UINT16 dataLen); + + + /******************************************************************************* + ** + ** Function: dequeue + ** + ** Description: Retrieve and remove data from the front of the queue. + ** buffer: array to store the data. + ** bufferMaxLen: maximum size of the buffer. + ** actualLen: actual length of the data. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool dequeue (UINT8* buffer, UINT16 bufferMaxLen, UINT16& actualLen); + + + /******************************************************************************* + ** + ** Function: isEmpty + ** + ** Description: Whether the queue is empty. + ** + ** Returns: True if empty. + ** + *******************************************************************************/ + bool isEmpty(); + +private: + struct tHeader + { + UINT16 mDataLen; //number of octets of data + UINT16 mOffset; //offset of the first octet of data + }; + typedef std::list Queue; + + Queue mQueue; + Mutex mMutex; +}; + diff --git a/nci/jni/HostAidRouter.cpp b/nci/jni/HostAidRouter.cpp new file mode 100644 index 0000000..0b511f8 --- /dev/null +++ b/nci/jni/HostAidRouter.cpp @@ -0,0 +1,291 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Manage listen-mode AID routing to the host. + */ +#include "OverrideLog.h" +#include "HostAidRouter.h" +#include "config.h" +#include "SecureElement.h" + + +HostAidRouter HostAidRouter::sHostAidRouter; //singleton HostAidRouter object + + +/******************************************************************************* +** +** Function: HostAidRouter +** +** Description: Private constructor to prevent public call. +** +** Returns: None. +** +*******************************************************************************/ +HostAidRouter::HostAidRouter () + : mTempHandle (NFA_HANDLE_INVALID), + mIsFeatureEnabled (true) +{ +} + + +/******************************************************************************* +** +** Function: ~HostAidRouter +** +** Description: Private destructor to prevent public call. +** +** Returns: None. +** +*******************************************************************************/ +HostAidRouter::~HostAidRouter () +{ +} + + +/******************************************************************************* +** +** Function: getInstance +** +** Description: Obtain a reference to the singleton object of HostAidRouter +** +** Returns: Reference to HostAidRouter object. +** +*******************************************************************************/ +HostAidRouter& HostAidRouter::getInstance () +{ + return sHostAidRouter; +} + + +/******************************************************************************* +** +** Function: initialize +** +** Description: Initialize all resources. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool HostAidRouter::initialize () +{ + unsigned long num = 0; + mTempHandle = NFA_HANDLE_INVALID; + mHandleDatabase.clear (); + + if (GetNumValue (NAME_REGISTER_VIRTUAL_SE, &num, sizeof (num))) + mIsFeatureEnabled = num != 0; + return true; +} + + +/******************************************************************************* +** +** Function: addPpseRoute +** +** Description: Route Proximity Payment System Environment request +** to the host. This function is called when there is no +** route data. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool HostAidRouter::addPpseRoute () +{ + static const char fn [] = "HostAidRouter::addPpseRoute"; + ALOGD ("%s: enter", fn); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + bool retval = false; + + if (! mIsFeatureEnabled) + { + ALOGD ("%s: feature disabled", fn); + goto TheEnd; + } + + { + ALOGD ("%s: register PPSE AID", fn); + SyncEventGuard guard (mRegisterEvent); + mTempHandle = NFA_HANDLE_INVALID; + nfaStat = NFA_CeRegisterAidOnDH ((UINT8*) "2PAY.SYS.DDF01", 14, stackCallback); + if (nfaStat == NFA_STATUS_OK) + { + mRegisterEvent.wait (); //wait for NFA_CE_REGISTERED_EVT + if (mTempHandle == NFA_HANDLE_INVALID) + { + ALOGE ("%s: received invalid handle", fn); + goto TheEnd; + } + else + mHandleDatabase.push_back (mTempHandle); + } + else + { + ALOGE ("%s: fail register", fn); + goto TheEnd; + } + } + retval = true; + +TheEnd: + ALOGD ("%s: exit; ok=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: deleteAllRoutes +** +** Description: Delete all AID routes to the host. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool HostAidRouter::deleteAllRoutes () +{ + static const char fn [] = "HostAidRouter::deleteAllRoutes"; + ALOGD ("%s: enter", fn); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + bool retval = false; + + if (! mIsFeatureEnabled) + { + ALOGD ("%s: feature disabled", fn); + goto TheEnd; + } + + //deregister each registered AID from the stack + for (AidHandleDatabase::iterator iter1 = mHandleDatabase.begin(); iter1 != mHandleDatabase.end(); iter1++) + { + tNFA_HANDLE aidHandle = *iter1; + ALOGD ("%s: deregister h=0x%X", fn, aidHandle); + SyncEventGuard guard (mDeregisterEvent); + nfaStat = NFA_CeDeregisterAidOnDH (aidHandle); + if (nfaStat == NFA_STATUS_OK) + mDeregisterEvent.wait (); //wait for NFA_CE_DEREGISTERED_EVT + else + ALOGE ("%s: fail deregister", fn); + } + mHandleDatabase.clear (); + retval = true; + +TheEnd: + ALOGD ("%s: exit; ok=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: startRoute +** +** Description: Begin to route AID request to the host. +** aid: Buffer that contains Application ID +** aidLen: Actual length of the buffer. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool HostAidRouter::startRoute (const UINT8* aid, UINT8 aidLen) +{ + static const char fn [] = "HostAidRouter::startRoute"; + ALOGD ("%s: enter", fn); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + bool retval = false; + + if (! mIsFeatureEnabled) + { + ALOGD ("%s: feature disabled", fn); + goto TheEnd; + } + + { + ALOGD ("%s: register AID; len=%u", fn, aidLen); + SyncEventGuard guard (mRegisterEvent); + mTempHandle = NFA_HANDLE_INVALID; + nfaStat = NFA_CeRegisterAidOnDH ((UINT8*) aid, aidLen, stackCallback); + if (nfaStat == NFA_STATUS_OK) + { + mRegisterEvent.wait (); //wait for NFA_CE_REGISTERED_EVT + if (mTempHandle == NFA_HANDLE_INVALID) + { + ALOGE ("%s: received invalid handle", fn); + goto TheEnd; + } + else + mHandleDatabase.push_back (mTempHandle); + } + else + { + ALOGE ("%s: fail register", fn); + goto TheEnd; + } + } + +TheEnd: + ALOGD ("%s: exit; ok=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: stackCallback +** +** Description: Receive events from the NFC stack. +** +** Returns: None. +** +*******************************************************************************/ +void HostAidRouter::stackCallback (UINT8 event, tNFA_CONN_EVT_DATA* eventData) +{ + static const char fn [] = "HostAidRouter::stackCallback"; + ALOGD("%s: event=0x%X", fn, event); + + switch (event) + { + case NFA_CE_REGISTERED_EVT: + { + tNFA_CE_REGISTERED& ce_registered = eventData->ce_registered; + ALOGD("%s: NFA_CE_REGISTERED_EVT; status=0x%X; h=0x%X", fn, ce_registered.status, ce_registered.handle); + SyncEventGuard guard (sHostAidRouter.mRegisterEvent); + if (ce_registered.status == NFA_STATUS_OK) + sHostAidRouter.mTempHandle = ce_registered.handle; + else + sHostAidRouter.mTempHandle = NFA_HANDLE_INVALID; + sHostAidRouter.mRegisterEvent.notifyOne(); + } + break; + + case NFA_CE_DEREGISTERED_EVT: + { + tNFA_CE_DEREGISTERED& ce_deregistered = eventData->ce_deregistered; + ALOGD("%s: NFA_CE_DEREGISTERED_EVT; h=0x%X", fn, ce_deregistered.handle); + SyncEventGuard guard (sHostAidRouter.mDeregisterEvent); + sHostAidRouter.mDeregisterEvent.notifyOne(); + } + break; + + case NFA_CE_DATA_EVT: + { + tNFA_CE_DATA& ce_data = eventData->ce_data; + ALOGD("%s: NFA_CE_DATA_EVT; h=0x%X; data len=%u", fn, ce_data.handle, ce_data.len); + SecureElement::getInstance().notifyTransactionListenersOfAid ((UINT8 *)"2PAY.SYS.DDF01", 14); + } + break; + } +} diff --git a/nci/jni/HostAidRouter.h b/nci/jni/HostAidRouter.h new file mode 100644 index 0000000..f653aa9 --- /dev/null +++ b/nci/jni/HostAidRouter.h @@ -0,0 +1,156 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Manage listen-mode AID routing to the host. + */ +#pragma once +#include "SyncEvent.h" +#include "NfcJniUtil.h" +#include "RouteDataSet.h" +#include +extern "C" +{ + #include "nfa_api.h" +} + + +class HostAidRouter +{ +public: + /******************************************************************************* + ** + ** Function: getInstance + ** + ** Description: Obtain a reference to the singleton object of HostAidRouter + ** + ** Returns: Reference to HostAidRouter object. + ** + *******************************************************************************/ + static HostAidRouter& getInstance (); + + + /******************************************************************************* + ** + ** Function: initialize + ** + ** Description: Initialize all resources. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool initialize (); + + + /******************************************************************************* + ** + ** Function: addPpseRoute + ** + ** Description: Route Proximity Payment System Environment request + ** to the host. This function is called when there is no + ** route data. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool addPpseRoute (); + + + /******************************************************************************* + ** + ** Function: deleteAllRoutes + ** + ** Description: Delete all AID routes to the host. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool deleteAllRoutes (); + + + /******************************************************************************* + ** + ** Function: isFeatureEnabled + ** + ** Description: Is AID-routing-to-host feature enabled? + ** + ** Returns: True if enabled. + ** + *******************************************************************************/ + bool isFeatureEnabled () {return mIsFeatureEnabled;}; + + + /******************************************************************************* + ** + ** Function: startRoute + ** + ** Description: Begin to route AID request to the host. + ** aid: Buffer that contains Application ID + ** aidLen: Actual length of the buffer. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool startRoute (const UINT8* aid, UINT8 aidLen); + + +private: + typedef std::vector AidHandleDatabase; + + tNFA_HANDLE mTempHandle; + bool mIsFeatureEnabled; + static HostAidRouter sHostAidRouter; //singleton object + RouteDataSet mRouteDataSet; //route data from xml file + SyncEvent mRegisterEvent; + SyncEvent mDeregisterEvent; + AidHandleDatabase mHandleDatabase; //store all AID handles that are registered with the stack + + + /******************************************************************************* + ** + ** Function: HostAidRouter + ** + ** Description: Private constructor to prevent public call. + ** + ** Returns: None. + ** + *******************************************************************************/ + HostAidRouter (); + + + /******************************************************************************* + ** + ** Function: ~HostAidRouter + ** + ** Description: Private destructor to prevent public call. + ** + ** Returns: None. + ** + *******************************************************************************/ + ~HostAidRouter (); + + + /******************************************************************************* + ** + ** Function: stackCallback + ** + ** Description: Receive events from the NFC stack. + ** + ** Returns: None. + ** + *******************************************************************************/ + static void stackCallback (UINT8 event, tNFA_CONN_EVT_DATA* eventdata); +}; diff --git a/nci/jni/IntervalTimer.cpp b/nci/jni/IntervalTimer.cpp new file mode 100644 index 0000000..f71ca8e --- /dev/null +++ b/nci/jni/IntervalTimer.cpp @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Asynchronous interval timer. + */ + +#include "IntervalTimer.h" +#include "OverrideLog.h" + + +IntervalTimer::IntervalTimer() +{ + mTimerId = NULL; + mCb = NULL; +} + + +bool IntervalTimer::set(int ms, TIMER_FUNC cb) +{ + if (mTimerId == NULL) + { + if (cb == NULL) + return false; + + if (!create(cb)) + return false; + } + if (cb != mCb) + { + kill(); + if (!create(cb)) + return false; + } + + int stat = 0; + struct itimerspec ts; + ts.it_value.tv_sec = ms / 1000; + ts.it_value.tv_nsec = (ms % 1000) * 1000000; + + ts.it_interval.tv_sec = 0; + ts.it_interval.tv_nsec = 0; + + stat = timer_settime(mTimerId, 0, &ts, 0); + if (stat == -1) + ALOGE("IntervalTimer::set: fail set timer"); + return stat == 0; +} + + +IntervalTimer::~IntervalTimer() +{ + kill(); +} + + +void IntervalTimer::kill() +{ + if (mTimerId == NULL) + return; + + timer_delete(mTimerId); + mTimerId = NULL; + mCb = NULL; +} + + +bool IntervalTimer::create(TIMER_FUNC cb) +{ + struct sigevent se; + int stat = 0; + + /* + * Set the sigevent structure to cause the signal to be + * delivered by creating a new thread. + */ + se.sigev_notify = SIGEV_THREAD; + se.sigev_value.sival_ptr = &mTimerId; + se.sigev_notify_function = cb; + se.sigev_notify_attributes = NULL; + mCb = cb; + stat = timer_create(CLOCK_MONOTONIC, &se, &mTimerId); + if (stat == -1) + ALOGE("IntervalTimer::create: fail create timer"); + return stat == 0; +} diff --git a/nci/jni/IntervalTimer.h b/nci/jni/IntervalTimer.h new file mode 100644 index 0000000..66e345d --- /dev/null +++ b/nci/jni/IntervalTimer.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Asynchronous interval timer. + */ + +#include + + +class IntervalTimer +{ +public: + typedef void (*TIMER_FUNC) (union sigval); + + IntervalTimer(); + ~IntervalTimer(); + bool set(int ms, TIMER_FUNC cb); + void kill(); + bool create(TIMER_FUNC ); + +private: + timer_t mTimerId; + TIMER_FUNC mCb; +}; diff --git a/nci/jni/JavaClassConstants.h b/nci/jni/JavaClassConstants.h new file mode 100644 index 0000000..30deca9 --- /dev/null +++ b/nci/jni/JavaClassConstants.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#pragma once + + +namespace android +{ + extern jmethodID gCachedNfcManagerNotifyNdefMessageListeners; + extern jmethodID gCachedNfcManagerNotifyTransactionListeners; + extern jmethodID gCachedNfcManagerNotifyLlcpLinkActivation; + extern jmethodID gCachedNfcManagerNotifyLlcpLinkDeactivated; + extern jmethodID gCachedNfcManagerNotifySeFieldActivated; + extern jmethodID gCachedNfcManagerNotifySeFieldDeactivated; + extern jmethodID gCachedNfcManagerNotifySeListenActivated; + extern jmethodID gCachedNfcManagerNotifySeListenDeactivated; + + extern const char* gNativeP2pDeviceClassName; + extern const char* gNativeLlcpServiceSocketClassName; + extern const char* gNativeLlcpConnectionlessSocketClassName; + extern const char* gNativeLlcpSocketClassName; + extern const char* gNativeNfcTagClassName; + extern const char* gNativeNfcManagerClassName; + extern const char* gNativeNfcSecureElementClassName; +} diff --git a/nci/jni/Mutex.cpp b/nci/jni/Mutex.cpp new file mode 100644 index 0000000..c0b12c0 --- /dev/null +++ b/nci/jni/Mutex.cpp @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Encapsulate a mutex for thread synchronization. + */ + +#include "Mutex.h" +#include "NfcJniUtil.h" +#include + +/******************************************************************************* +** +** Function: Mutex +** +** Description: Initialize member variables. +** +** Returns: None. +** +*******************************************************************************/ +Mutex::Mutex () +{ + memset (&mMutex, 0, sizeof(mMutex)); + int res = pthread_mutex_init (&mMutex, NULL); + if (res != 0) + { + ALOGE ("Mutex::Mutex: fail init; error=0x%X", res); + } +} + + +/******************************************************************************* +** +** Function: ~Mutex +** +** Description: Cleanup all resources. +** +** Returns: None. +** +*******************************************************************************/ +Mutex::~Mutex () +{ + int res = pthread_mutex_destroy (&mMutex); + if (res != 0) + { + ALOGE ("Mutex::~Mutex: fail destroy; error=0x%X", res); + } +} + + +/******************************************************************************* +** +** Function: lock +** +** Description: Block the thread and try lock the mutex. +** +** Returns: None. +** +*******************************************************************************/ +void Mutex::lock () +{ + int res = pthread_mutex_lock (&mMutex); + if (res != 0) + { + ALOGE ("Mutex::lock: fail lock; error=0x%X", res); + } +} + + +/******************************************************************************* +** +** Function: unlock +** +** Description: Unlock a mutex to unblock a thread. +** +** Returns: None. +** +*******************************************************************************/ +void Mutex::unlock () +{ + int res = pthread_mutex_unlock (&mMutex); + if (res != 0) + { + ALOGE ("Mutex::unlock: fail unlock; error=0x%X", res); + } +} + + +/******************************************************************************* +** +** Function: tryLock +** +** Description: Try to lock the mutex. +** +** Returns: True if the mutex is locked. +** +*******************************************************************************/ +bool Mutex::tryLock () +{ + int res = pthread_mutex_trylock (&mMutex); + if ((res != 0) && (res != EBUSY)) + { + ALOGE ("Mutex::tryLock: error=0x%X", res); + } + return res == 0; +} + + +/******************************************************************************* +** +** Function: nativeHandle +** +** Description: Get the handle of the mutex. +** +** Returns: Handle of the mutex. +** +*******************************************************************************/ +pthread_mutex_t* Mutex::nativeHandle () +{ + return &mMutex; +} + + diff --git a/nci/jni/Mutex.h b/nci/jni/Mutex.h new file mode 100644 index 0000000..45f42de --- /dev/null +++ b/nci/jni/Mutex.h @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Encapsulate a mutex for thread synchronization. + */ + +#pragma once +#include + + +class Mutex +{ +public: + /******************************************************************************* + ** + ** Function: Mutex + ** + ** Description: Initialize member variables. + ** + ** Returns: None. + ** + *******************************************************************************/ + Mutex (); + + + /******************************************************************************* + ** + ** Function: ~Mutex + ** + ** Description: Cleanup all resources. + ** + ** Returns: None. + ** + *******************************************************************************/ + ~Mutex (); + + + /******************************************************************************* + ** + ** Function: lock + ** + ** Description: Block the thread and try lock the mutex. + ** + ** Returns: None. + ** + *******************************************************************************/ + void lock (); + + + /******************************************************************************* + ** + ** Function: unlock + ** + ** Description: Unlock a mutex to unblock a thread. + ** + ** Returns: None. + ** + *******************************************************************************/ + void unlock (); + + + /******************************************************************************* + ** + ** Function: tryLock + ** + ** Description: Try to lock the mutex. + ** + ** Returns: True if the mutex is locked. + ** + *******************************************************************************/ + bool tryLock (); + + + /******************************************************************************* + ** + ** Function: nativeHandle + ** + ** Description: Get the handle of the mutex. + ** + ** Returns: Handle of the mutex. + ** + *******************************************************************************/ + pthread_mutex_t* nativeHandle (); + + class Autolock { + public: + inline Autolock(Mutex& mutex) : mLock(mutex) { mLock.lock(); } + inline Autolock(Mutex* mutex) : mLock(*mutex) { mLock.lock(); } + inline ~Autolock() { mLock.unlock(); } + private: + Mutex& mLock; + }; + + +private: + pthread_mutex_t mMutex; +}; + +typedef Mutex::Autolock AutoMutex; diff --git a/nci/jni/NativeLlcpConnectionlessSocket.cpp b/nci/jni/NativeLlcpConnectionlessSocket.cpp new file mode 100644 index 0000000..ecc57e3 --- /dev/null +++ b/nci/jni/NativeLlcpConnectionlessSocket.cpp @@ -0,0 +1,311 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "OverrideLog.h" +#include "NfcJniUtil.h" +#include "JavaClassConstants.h" +extern "C" +{ + #include "nfa_api.h" + #include "nfa_p2p_api.h" +} + + +namespace android +{ + + +/***************************************************************************** +** +** private variables and functions +** +*****************************************************************************/ +static sem_t sConnlessRecvSem; +static jboolean sConnlessRecvWaitingForData = JNI_FALSE; +static uint8_t* sConnlessRecvBuf = NULL; +static uint32_t sConnlessRecvLen = 0; +static uint32_t sConnlessRecvRemoteSap = 0; + + +/******************************************************************************* +** +** Function: nativeLlcpConnectionlessSocket_doSendTo +** +** Description: Send data to peer. +** e: JVM environment. +** o: Java object. +** nsap: service access point. +** data: buffer for data. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeLlcpConnectionlessSocket_doSendTo (JNIEnv *e, jobject o, jint nsap, jbyteArray data) +{ + tNFA_STATUS status = NFA_STATUS_FAILED; + jint handle = 0; + uint8_t* buf = NULL; + uint32_t len = 0; + jclass c = NULL; + jfieldID f = NULL; + + ALOGD ("%s: nsap = %d", __FUNCTION__, nsap); + + c = e->GetObjectClass (o); + f = e->GetFieldID (c, "mHandle", "I"); + handle = e->GetIntField (o, f); + + buf = (uint8_t*) e->GetByteArrayElements (data, NULL); + len = (uint32_t) e->GetArrayLength (data); + + ALOGD ("NFA_P2pSendUI: len = %d", len); + status = NFA_P2pSendUI ((tNFA_HANDLE) handle, nsap, len, buf); + + ALOGD ("%s: NFA_P2pSendUI done, status = %d", __FUNCTION__, status); + if (status != NFA_STATUS_OK) + { + ALOGE ("%s: NFA_P2pSendUI failed, status = %d", __FUNCTION__, status); + return JNI_FALSE; + } + return JNI_TRUE; +} + + +/******************************************************************************* +** +** Function: nativeLlcpConnectionlessSocket_receiveData +** +** Description: Receive data from the stack. +** data: buffer contains data. +** len: length of data. +** remoteSap: remote service access point. +** +** Returns: None +** +*******************************************************************************/ +void nativeLlcpConnectionlessSocket_receiveData (uint8_t* data, uint32_t len, uint32_t remoteSap) +{ + ALOGD ("%s: waiting for data = %d, len = %d", __FUNCTION__, sConnlessRecvWaitingForData, len); + + // Sanity... + if (sConnlessRecvLen < len) + { + len = sConnlessRecvLen; + } + + if (sConnlessRecvWaitingForData) + { + sConnlessRecvWaitingForData = JNI_FALSE; + sConnlessRecvLen = len; + memcpy (sConnlessRecvBuf, data, len); + sConnlessRecvRemoteSap = remoteSap; + + sem_post (&sConnlessRecvSem); + } +} + + +/******************************************************************************* +** +** Function: connectionlessCleanup +** +** Description: Free resources. +** +** Returns: None +** +*******************************************************************************/ +static jobject connectionlessCleanup () +{ + sConnlessRecvWaitingForData = JNI_FALSE; + sConnlessRecvLen = 0; + if (sConnlessRecvBuf != NULL) + { + free (sConnlessRecvBuf); + sConnlessRecvBuf = NULL; + } + return NULL; +} + + +/******************************************************************************* +** +** Function: nativeLlcpConnectionlessSocket_abortWait +** +** Description: Abort current operation and unblock threads. +** +** Returns: None +** +*******************************************************************************/ +void nativeLlcpConnectionlessSocket_abortWait () +{ + sem_post (&sConnlessRecvSem); +} + + +/******************************************************************************* +** +** Function: nativeLlcpConnectionlessSocket_doReceiveFrom +** +** Description: Receive data from a peer. +** e: JVM environment. +** o: Java object. +** linkMiu: max info unit +** +** Returns: LlcpPacket Java object. +** +*******************************************************************************/ +static jobject nativeLlcpConnectionlessSocket_doReceiveFrom (JNIEnv *e, jobject o, jint linkMiu) +{ + jbyteArray receivedData = NULL; + jobject llcpPacket = NULL; + jclass clsLlcpPacket = NULL; + jfieldID f = NULL; + + ALOGD ("%s: linkMiu = %d", __FUNCTION__, linkMiu); + + if (sConnlessRecvWaitingForData != JNI_FALSE) + { + ALOGD ("%s: Already waiting for incoming data", __FUNCTION__); + return NULL; + } + + sConnlessRecvBuf = (uint8_t*) malloc (linkMiu); + if (sConnlessRecvBuf == NULL) + { + ALOGD ("%s: Failed to allocate %d bytes memory buffer", __FUNCTION__, linkMiu); + return NULL; + } + sConnlessRecvLen = linkMiu; + + // Create the write semaphore + if (sem_init (&sConnlessRecvSem, 0, 0) == -1) + { + ALOGE ("%s: semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno); + return connectionlessCleanup (); + } + + sConnlessRecvWaitingForData = JNI_TRUE; + + // Wait for sConnlessRecvSem completion status + if (sem_wait (&sConnlessRecvSem)) + { + ALOGE ("%s: Failed to wait for write semaphore (errno=0x%08x)", __FUNCTION__, errno); + goto TheEnd; + } + + // Create new LlcpPacket object + if (nfc_jni_cache_object (e, "com/android/nfc/LlcpPacket", &(llcpPacket)) == -1) + { + ALOGE ("%s: Find LlcpPacket class error", __FUNCTION__); + return connectionlessCleanup (); + } + + // Get NativeConnectionless class object + clsLlcpPacket = e->GetObjectClass (llcpPacket); + if (e->ExceptionCheck ()) + { + e->ExceptionClear(); + ALOGE ("%s: Get Object class error", __FUNCTION__); + return connectionlessCleanup (); + } + + // Set Llcp Packet remote SAP + f = e->GetFieldID (clsLlcpPacket, "mRemoteSap", "I"); + e->SetIntField (llcpPacket, f, (jbyte) sConnlessRecvRemoteSap); + + // Set Llcp Packet Buffer + ALOGD ("%s: Received Llcp packet buffer size = %d\n", __FUNCTION__, sConnlessRecvLen); + f = e->GetFieldID (clsLlcpPacket, "mDataBuffer", "[B"); + receivedData = e->NewByteArray (sConnlessRecvLen); + e->SetByteArrayRegion (receivedData, 0, sConnlessRecvLen, (jbyte*) sConnlessRecvBuf); + e->SetObjectField (llcpPacket, f, receivedData); + +TheEnd: + connectionlessCleanup (); + if (sem_destroy (&sConnlessRecvSem)) + { + ALOGE ("%s: Failed to destroy sConnlessRecvSem semaphore (errno=0x%08x)", __FUNCTION__, errno); + } + return llcpPacket; +} + + +/******************************************************************************* +** +** Function: nativeLlcpConnectionlessSocket_doClose +** +** Description: Close socket. +** e: JVM environment. +** o: Java object. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeLlcpConnectionlessSocket_doClose (JNIEnv *e, jobject o) +{ + tNFA_STATUS status = NFA_STATUS_FAILED; + jint handle = 0; + jclass c = NULL; + jfieldID f = NULL; + + ALOGD ("%s", __FUNCTION__); + + c = e->GetObjectClass (o); + f = e->GetFieldID (c, "mHandle", "I"); + handle = e->GetIntField (o, f); + + status = NFA_P2pDisconnect ((tNFA_HANDLE) handle, FALSE); + if (status != NFA_STATUS_OK) + { + ALOGE ("%s: disconnect failed, status = %d", __FUNCTION__, status); + return JNI_FALSE; + } + return JNI_TRUE; +} + + +/***************************************************************************** +** +** Description: JNI functions +** +*****************************************************************************/ +static JNINativeMethod gMethods[] = +{ + {"doSendTo", "(I[B)Z", (void*) nativeLlcpConnectionlessSocket_doSendTo}, + {"doReceiveFrom", "(I)Lcom/android/nfc/LlcpPacket;", (void*) nativeLlcpConnectionlessSocket_doReceiveFrom}, + {"doClose", "()Z", (void*) nativeLlcpConnectionlessSocket_doClose}, +}; + + +/******************************************************************************* +** +** Function: register_com_android_nfc_NativeLlcpConnectionlessSocket +** +** Description: Regisgter JNI functions with Java Virtual Machine. +** e: Environment of JVM. +** +** Returns: Status of registration. +** +*******************************************************************************/ +int register_com_android_nfc_NativeLlcpConnectionlessSocket (JNIEnv *e) +{ + return jniRegisterNativeMethods (e, gNativeLlcpConnectionlessSocketClassName, gMethods, NELEM(gMethods)); +} + + +} // android namespace diff --git a/nci/jni/NativeLlcpServiceSocket.cpp b/nci/jni/NativeLlcpServiceSocket.cpp new file mode 100644 index 0000000..e1c2bb5 --- /dev/null +++ b/nci/jni/NativeLlcpServiceSocket.cpp @@ -0,0 +1,158 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "OverrideLog.h" +#include "NfcJniUtil.h" +#include "NfcAdaptation.h" +#include "PeerToPeer.h" +#include "JavaClassConstants.h" +extern "C" +{ + #include "nfa_api.h" + #include "nfa_p2p_api.h" +} + + +namespace android +{ + + +/******************************************************************************* +** +** Function: nativeLlcpServiceSocket_doAccept +** +** Description: Accept a connection request from a peer. +** e: JVM environment. +** o: Java object. +** miu: Maximum information unit. +** rw: Receive window. +** linearBufferLength: Not used. +** +** Returns: LlcpSocket Java object. +** +*******************************************************************************/ +static jobject nativeLlcpServiceSocket_doAccept(JNIEnv *e, jobject o, jint miu, jint rw, jint linearBufferLength) +{ + jobject clientSocket = NULL; + jclass clsNativeLlcpSocket = NULL; + jfieldID f = 0; + PeerToPeer::tJNI_HANDLE serverHandle; //handle of the local server + bool stat = false; + PeerToPeer::tJNI_HANDLE connHandle = PeerToPeer::getInstance().getNewJniHandle (); + + ALOGD ("%s: enter", __FUNCTION__); + + serverHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e, o); + + stat = PeerToPeer::getInstance().accept (serverHandle, connHandle, miu, rw); + + if (! stat) + { + ALOGE ("%s: fail accept", __FUNCTION__); + goto TheEnd; + } + + /* Create new LlcpSocket object */ + if (nfc_jni_cache_object(e, gNativeLlcpSocketClassName, &(clientSocket)) == -1) + { + ALOGE ("%s: fail create NativeLlcpSocket", __FUNCTION__); + goto TheEnd; + } + + /* Get NativeConnectionOriented class object */ + clsNativeLlcpSocket = e->GetObjectClass (clientSocket); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: get class object error", __FUNCTION__); + goto TheEnd; + } + + /* Set socket handle */ + f = e->GetFieldID (clsNativeLlcpSocket, "mHandle", "I"); + e->SetIntField (clientSocket, f, (jint) connHandle); + + /* Set socket MIU */ + f = e->GetFieldID (clsNativeLlcpSocket, "mLocalMiu", "I"); + e->SetIntField (clientSocket, f, (jint)miu); + + /* Set socket RW */ + f = e->GetFieldID (clsNativeLlcpSocket, "mLocalRw", "I"); + e->SetIntField (clientSocket, f, (jint)rw); + +TheEnd: + ALOGD ("%s: exit", __FUNCTION__); + return clientSocket; +} + + +/******************************************************************************* +** +** Function: nativeLlcpServiceSocket_doClose +** +** Description: Close a server socket. +** e: JVM environment. +** o: Java object. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeLlcpServiceSocket_doClose(JNIEnv *e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + PeerToPeer::tJNI_HANDLE jniServerHandle = 0; + bool stat = false; + + jniServerHandle = nfc_jni_get_nfc_socket_handle (e, o); + + stat = PeerToPeer::getInstance().deregisterServer (jniServerHandle); + + ALOGD ("%s: exit", __FUNCTION__); + return JNI_TRUE; +} + + +/***************************************************************************** +** +** Description: JNI functions +** +*****************************************************************************/ +static JNINativeMethod gMethods[] = +{ + {"doAccept", "(III)Lcom/android/nfc/dhimpl/NativeLlcpSocket;", (void*) nativeLlcpServiceSocket_doAccept}, + {"doClose", "()Z", (void*) nativeLlcpServiceSocket_doClose}, +}; + + +/******************************************************************************* +** +** Function: register_com_android_nfc_NativeLlcpServiceSocket +** +** Description: Regisgter JNI functions with Java Virtual Machine. +** e: Environment of JVM. +** +** Returns: Status of registration. +** +*******************************************************************************/ +int register_com_android_nfc_NativeLlcpServiceSocket (JNIEnv* e) +{ + return jniRegisterNativeMethods (e, gNativeLlcpServiceSocketClassName, + gMethods, NELEM(gMethods)); +} + + +} //namespace android + diff --git a/nci/jni/NativeLlcpSocket.cpp b/nci/jni/NativeLlcpSocket.cpp new file mode 100644 index 0000000..74a59b9 --- /dev/null +++ b/nci/jni/NativeLlcpSocket.cpp @@ -0,0 +1,271 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "OverrideLog.h" +#include "PeerToPeer.h" +#include "JavaClassConstants.h" + + +namespace android +{ + + +/******************************************************************************* +** +** Function: nativeLlcpSocket_doConnect +** +** Description: Establish a connection to the peer. +** e: JVM environment. +** o: Java object. +** nSap: Service access point. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeLlcpSocket_doConnect (JNIEnv* e, jobject o, jint nSap) +{ + bool stat = false; + jboolean retVal = JNI_FALSE; + + ALOGD ("%s: enter; sap=%d", __FUNCTION__, nSap); + + PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e,o); + + stat = PeerToPeer::getInstance().connectConnOriented (jniHandle, nSap); + + if (stat) + retVal = JNI_TRUE; + + ALOGD ("%s: exit", __FUNCTION__); + return retVal; +} + + +/******************************************************************************* +** +** Function: nativeLlcpSocket_doConnectBy +** +** Description: Establish a connection to the peer. +** e: JVM environment. +** o: Java object. +** sn: Service name. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeLlcpSocket_doConnectBy (JNIEnv* e, jobject o, jstring sn) +{ + ALOGD ("%s: enter", __FUNCTION__); + bool stat = false; + jboolean retVal = JNI_FALSE; + + PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e,o); + + const char* serviceName = e->GetStringUTFChars (sn, JNI_FALSE); //convert jstring, which is unicode, into char* + + stat = PeerToPeer::getInstance().connectConnOriented (jniHandle, serviceName); + + e->ReleaseStringUTFChars (sn, serviceName); //free the string + + if (stat) + retVal = JNI_TRUE; + + ALOGD ("%s: exit", __FUNCTION__); + return retVal; +} + + +/******************************************************************************* +** +** Function: nativeLlcpSocket_doClose +** +** Description: Close socket. +** e: JVM environment. +** o: Java object. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeLlcpSocket_doClose(JNIEnv *e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + bool stat = false; + jboolean retVal = JNI_FALSE; + + PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e,o); + + stat = PeerToPeer::getInstance().disconnectConnOriented (jniHandle); + + retVal = JNI_TRUE; + ALOGD ("%s: exit", __FUNCTION__); + return retVal; +} + + +/******************************************************************************* +** +** Function: nativeLlcpSocket_doSend +** +** Description: Send data to peer. +** e: JVM environment. +** o: Java object. +** data: Buffer of data. +** +** Returns: True if sent ok. +** +*******************************************************************************/ +static jboolean nativeLlcpSocket_doSend (JNIEnv* e, jobject o, jbyteArray data) +{ + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter", __FUNCTION__); + uint8_t* dataBuffer = (uint8_t*) e->GetByteArrayElements (data, NULL); + uint32_t dataBufferLen = (uint32_t) e->GetArrayLength (data); + bool stat = false; + + PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e,o); + + stat = PeerToPeer::getInstance().send (jniHandle, dataBuffer, dataBufferLen); + + e->ReleaseByteArrayElements (data, (jbyte*) dataBuffer, JNI_ABORT); + + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit", __FUNCTION__); + return stat ? JNI_TRUE : JNI_FALSE; +} + + +/******************************************************************************* +** +** Function: nativeLlcpSocket_doReceive +** +** Description: Receive data from peer. +** e: JVM environment. +** o: Java object. +** origBuffer: Buffer to put received data. +** +** Returns: Number of bytes received. +** +*******************************************************************************/ +static jint nativeLlcpSocket_doReceive(JNIEnv *e, jobject o, jbyteArray origBuffer) +{ + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter", __FUNCTION__); + uint8_t* dataBuffer = (uint8_t*) e->GetByteArrayElements (origBuffer, NULL); + uint32_t dataBufferLen = (uint32_t) e->GetArrayLength (origBuffer); + uint16_t actualLen = 0; + bool stat = false; + jint retval = 0; + + PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e,o); + + stat = PeerToPeer::getInstance().receive (jniHandle, dataBuffer, dataBufferLen, actualLen); + + if (stat && (actualLen>0)) + { + retval = actualLen; + } + else + retval = -1; + + e->ReleaseByteArrayElements (origBuffer, (jbyte*) dataBuffer, 0); + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit; actual len=%d", __FUNCTION__, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: nativeLlcpSocket_doGetRemoteSocketMIU +** +** Description: Get peer's maximum information unit. +** e: JVM environment. +** o: Java object. +** +** Returns: Peer's maximum information unit. +** +*******************************************************************************/ +static jint nativeLlcpSocket_doGetRemoteSocketMIU (JNIEnv* e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + bool stat = false; + + PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e,o); + jint miu = 0; + + miu = PeerToPeer::getInstance().getRemoteMaxInfoUnit (jniHandle); + + ALOGD ("%s: exit", __FUNCTION__); + return miu; +} + + +/******************************************************************************* +** +** Function: nativeLlcpSocket_doGetRemoteSocketRW +** +** Description: Get peer's receive window size. +** e: JVM environment. +** o: Java object. +** +** Returns: Peer's receive window size. +** +*******************************************************************************/ +static jint nativeLlcpSocket_doGetRemoteSocketRW (JNIEnv* e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + bool stat = false; + jint rw = 0; + + PeerToPeer::tJNI_HANDLE jniHandle = (PeerToPeer::tJNI_HANDLE) nfc_jni_get_nfc_socket_handle (e,o); + + rw = PeerToPeer::getInstance().getRemoteRecvWindow (jniHandle); + + ALOGD ("%s: exit", __FUNCTION__); + return rw; +} + + +/***************************************************************************** +** +** Description: JNI functions +** +*****************************************************************************/ +static JNINativeMethod gMethods[] = +{ + {"doConnect", "(I)Z", (void * ) nativeLlcpSocket_doConnect}, + {"doConnectBy", "(Ljava/lang/String;)Z", (void*) nativeLlcpSocket_doConnectBy}, + {"doClose", "()Z", (void *) nativeLlcpSocket_doClose}, + {"doSend", "([B)Z", (void *) nativeLlcpSocket_doSend}, + {"doReceive", "([B)I", (void *) nativeLlcpSocket_doReceive}, + {"doGetRemoteSocketMiu", "()I", (void *) nativeLlcpSocket_doGetRemoteSocketMIU}, + {"doGetRemoteSocketRw", "()I", (void *) nativeLlcpSocket_doGetRemoteSocketRW}, +}; + + +/******************************************************************************* +** +** Function: register_com_android_nfc_NativeLlcpSocket +** +** Description: Regisgter JNI functions with Java Virtual Machine. +** e: Environment of JVM. +** +** Returns: Status of registration. +** +*******************************************************************************/ +int register_com_android_nfc_NativeLlcpSocket (JNIEnv* e) +{ + return jniRegisterNativeMethods (e, gNativeLlcpSocketClassName, gMethods, NELEM(gMethods)); +} + + +} //namespace android + diff --git a/nci/jni/NativeNfcManager.cpp b/nci/jni/NativeNfcManager.cpp new file mode 100755 index 0000000..f15c92f --- /dev/null +++ b/nci/jni/NativeNfcManager.cpp @@ -0,0 +1,1816 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "OverrideLog.h" +#include "NfcJniUtil.h" +#include "NfcAdaptation.h" +#include "SyncEvent.h" +#include "PeerToPeer.h" +#include "SecureElement.h" +#include "NfcTag.h" +#include "config.h" +#include "PowerSwitch.h" +#include "JavaClassConstants.h" +#include "Pn544Interop.h" + +extern "C" +{ + #include "nfa_api.h" + #include "nfa_p2p_api.h" + #include "rw_api.h" + #include "nfa_ee_api.h" + #include "nfc_brcm_defs.h" + #include "nfa_cho_api.h" + #include "ce_api.h" +} + +extern UINT8 *p_nfa_dm_lptd_cfg; +extern UINT8 *p_nfa_dm_start_up_cfg; +extern const UINT8 nfca_version_string []; +namespace android +{ + extern bool gIsTagDeactivating; + extern bool gIsSelectingRfInterface; + extern void nativeNfcTag_doTransceiveStatus (uint8_t * buf, uint32_t buflen); + extern void nativeNfcTag_doConnectStatus (jboolean is_connect_ok); + extern void nativeNfcTag_doDeactivateStatus (int status); + extern void nativeNfcTag_doWriteStatus (jboolean is_write_ok); + extern void nativeNfcTag_doCheckNdefResult (tNFA_STATUS status, uint32_t max_size, uint32_t current_size, uint8_t flags); + extern void nativeNfcTag_doMakeReadonlyResult (tNFA_STATUS status); + extern void nativeNfcTag_doPresenceCheckResult (tNFA_STATUS status); + extern void nativeNfcTag_formatStatus (bool is_ok); + extern void nativeNfcTag_resetPresenceCheck (); + extern void nativeNfcTag_doReadCompleted (tNFA_STATUS status); + extern void nativeNfcTag_abortWaits (); + extern void nativeLlcpConnectionlessSocket_abortWait (); + extern void nativeNfcTag_registerNdefTypeHandler (); + extern void nativeLlcpConnectionlessSocket_receiveData (uint8_t* data, uint32_t len, uint32_t remote_sap); +} + + +/***************************************************************************** +** +** public variables and functions +** +*****************************************************************************/ + +namespace android +{ + int gGeneralTransceiveTimeout = 1000; + jmethodID gCachedNfcManagerNotifyNdefMessageListeners; + jmethodID gCachedNfcManagerNotifyTransactionListeners; + jmethodID gCachedNfcManagerNotifyLlcpLinkActivation; + jmethodID gCachedNfcManagerNotifyLlcpLinkDeactivated; + jmethodID gCachedNfcManagerNotifySeFieldActivated; + jmethodID gCachedNfcManagerNotifySeFieldDeactivated; + jmethodID gCachedNfcManagerNotifySeListenActivated; + jmethodID gCachedNfcManagerNotifySeListenDeactivated; + const char* gNativeP2pDeviceClassName = "com/android/nfc/dhimpl/NativeP2pDevice"; + const char* gNativeLlcpServiceSocketClassName = "com/android/nfc/dhimpl/NativeLlcpServiceSocket"; + const char* gNativeLlcpConnectionlessSocketClassName = "com/android/nfc/dhimpl/NativeLlcpConnectionlessSocket"; + const char* gNativeLlcpSocketClassName = "com/android/nfc/dhimpl/NativeLlcpSocket"; + const char* gNativeNfcTagClassName = "com/android/nfc/dhimpl/NativeNfcTag"; + const char* gNativeNfcManagerClassName = "com/android/nfc/dhimpl/NativeNfcManager"; + const char* gNativeNfcSecureElementClassName = "com/android/nfc/dhimpl/NativeNfcSecureElement"; + void doStartupConfig (); + void startStopPolling (bool isStartPolling); + void startRfDiscovery (bool isStart); +} + + +/***************************************************************************** +** +** private variables and functions +** +*****************************************************************************/ +namespace android +{ +static jint sLastError = ERROR_BUFFER_TOO_SMALL; +static jmethodID sCachedNfcManagerNotifySeApduReceived; +static jmethodID sCachedNfcManagerNotifySeMifareAccess; +static jmethodID sCachedNfcManagerNotifySeEmvCardRemoval; +static jmethodID sCachedNfcManagerNotifyTargetDeselected; +static SyncEvent sNfaEnableEvent; //event for NFA_Enable() +static SyncEvent sNfaDisableEvent; //event for NFA_Disable() +static SyncEvent sNfaEnableDisablePollingEvent; //event for NFA_EnablePolling(), NFA_DisablePolling() +static SyncEvent sNfaSetConfigEvent; // event for Set_Config.... +static bool sIsNfaEnabled = false; +static bool sDiscoveryEnabled = false; //is polling for tag? +static bool sIsDisabling = false; +static bool sRfEnabled = false; // whether RF discovery is enabled +static bool sSeRfActive = false; // whether RF with SE is likely active +static bool sP2pActive = false; // whether p2p was last active +static int sConnlessSap = 0; +static int sConnlessLinkMiu = 0; +static bool sAbortConnlessWait = false; +static bool sIsSecElemSelected = false; //has NFC service selected a sec elem +static UINT8 * sOriginalLptdCfg = NULL; +static UINT8 sNewLptdCfg[LPTD_PARAM_LEN]; +static UINT32 sConfigUpdated = 0; +#define CONFIG_UPDATE_LPTD (1 << 0) +#define CONFIG_UPDATE_TECH_MASK (1 << 1) +#define DEFAULT_TECH_MASK (NFA_TECHNOLOGY_MASK_A \ + | NFA_TECHNOLOGY_MASK_B \ + | NFA_TECHNOLOGY_MASK_F \ + | NFA_TECHNOLOGY_MASK_ISO15693 \ + | NFA_TECHNOLOGY_MASK_B_PRIME \ + | NFA_TECHNOLOGY_MASK_A_ACTIVE \ + | NFA_TECHNOLOGY_MASK_F_ACTIVE) + + +static void nfaConnectionCallback (UINT8 event, tNFA_CONN_EVT_DATA *eventData); +static void nfaDeviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA *eventData); +static bool isPeerToPeer (tNFA_ACTIVATED& activated); +static bool isListenMode(tNFA_ACTIVATED& activated); + +///////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////// + + +/******************************************************************************* +** +** Function: getNative +** +** Description: Get native data +** +** Returns: Native data structure. +** +*******************************************************************************/ +nfc_jni_native_data *getNative (JNIEnv* e, jobject o) +{ + static struct nfc_jni_native_data *sCachedNat = NULL; + if (e) + { + sCachedNat = nfc_jni_get_nat(e, o); + } + return sCachedNat; +} + + +/******************************************************************************* +** +** Function: handleRfDiscoveryEvent +** +** Description: Handle RF-discovery events from the stack. +** discoveredDevice: Discovered device. +** +** Returns: None +** +*******************************************************************************/ +static void handleRfDiscoveryEvent (tNFC_RESULT_DEVT* discoveredDevice) +{ + if (discoveredDevice->more) + { + //there is more discovery notification coming + return; + } + + bool isP2p = NfcTag::getInstance ().isP2pDiscovered (); + if (isP2p) + { + //select the peer that supports P2P + NfcTag::getInstance ().selectP2p(); + } + else + { + //select the first of multiple tags that is discovered + NfcTag::getInstance ().selectFirstTag(); + } +} + + +/******************************************************************************* +** +** Function: nfaConnectionCallback +** +** Description: Receive connection-related events from stack. +** connEvent: Event code. +** eventData: Event data. +** +** Returns: None +** +*******************************************************************************/ +static void nfaConnectionCallback (UINT8 connEvent, tNFA_CONN_EVT_DATA* eventData) +{ + tNFA_STATUS status = NFA_STATUS_FAILED; + ALOGD("%s: event= %u", __FUNCTION__, connEvent); + + if (gIsTagDeactivating && connEvent != NFA_DEACTIVATED_EVT && connEvent != NFA_PRESENCE_CHECK_EVT && connEvent != NFA_DATA_EVT) + { + // special case to switching frame interface for ISO_DEP tags + gIsTagDeactivating = false; + ALOGD("%s: deactivating, should get NFA_DEACTIVATED_EVT", __FUNCTION__); + nativeNfcTag_doDeactivateStatus(1); + } + + switch (connEvent) + { + case NFA_POLL_ENABLED_EVT: // whether polling successfully started + { + ALOGD("%s: NFA_POLL_ENABLED_EVT: status = %u", __FUNCTION__, eventData->status); + + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + sNfaEnableDisablePollingEvent.notifyOne (); + } + break; + + case NFA_POLL_DISABLED_EVT: // Listening/Polling stopped + { + ALOGD("%s: NFA_POLL_DISABLED_EVT: status = %u", __FUNCTION__, eventData->status); + + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + sNfaEnableDisablePollingEvent.notifyOne (); + } + break; + + case NFA_RF_DISCOVERY_STARTED_EVT: // RF Discovery started + { + ALOGD("%s: NFA_RF_DISCOVERY_STARTED_EVT: status = %u", __FUNCTION__, eventData->status); + + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + sNfaEnableDisablePollingEvent.notifyOne (); + } + break; + + case NFA_RF_DISCOVERY_STOPPED_EVT: // RF Discovery stopped event + { + ALOGD("%s: NFA_RF_DISCOVERY_STOPPED_EVT: status = %u", __FUNCTION__, eventData->status); + + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + sNfaEnableDisablePollingEvent.notifyOne (); + } + break; + + case NFA_DISC_RESULT_EVT: // NFC link/protocol discovery notificaiton + status = eventData->disc_result.status; + ALOGD("%s: NFA_DISC_RESULT_EVT: status = %d", __FUNCTION__, status); + if (status != NFA_STATUS_OK) + { + ALOGE("%s: NFA_DISC_RESULT_EVT error: status = %d", __FUNCTION__, status); + } + else + { + NfcTag::getInstance().connectionEventHandler(connEvent, eventData); + handleRfDiscoveryEvent(&eventData->disc_result.discovery_ntf); + } + break; + + case NFA_SELECT_RESULT_EVT: // NFC link/protocol discovery select response + ALOGD("%s: NFA_SELECT_RESULT_EVT: status = %d, gIsSelectingRfInterface = %d, sIsDisabling=%d", __FUNCTION__, eventData->status, gIsSelectingRfInterface, sIsDisabling); + + if (sIsDisabling) + break; + + if (eventData->status != NFA_STATUS_OK) + { + if (gIsSelectingRfInterface) + { + nativeNfcTag_doConnectStatus(false); + } + + ALOGE("%s: NFA_SELECT_RESULT_EVT error: status = %d", __FUNCTION__, eventData->status); + NFA_Deactivate (FALSE); + } + break; + + case NFA_DEACTIVATE_FAIL_EVT: + ALOGD("%s: NFA_DEACTIVATE_FAIL_EVT: status = %d", __FUNCTION__, eventData->status); + break; + + case NFA_ACTIVATED_EVT: // NFC link/protocol activated + ALOGD("%s: NFA_ACTIVATED_EVT: gIsSelectingRfInterface=%d, sIsDisabling=%d", __FUNCTION__, gIsSelectingRfInterface, sIsDisabling); + if (sIsDisabling) + break; + + NfcTag::getInstance().setActivationState (); + if (gIsSelectingRfInterface) + { + nativeNfcTag_doConnectStatus(true); + break; + } + + nativeNfcTag_resetPresenceCheck(); + if (isPeerToPeer(eventData->activated)) + { + sP2pActive = true; + ALOGD("%s: NFA_ACTIVATED_EVT; is p2p", __FUNCTION__); + // Disable RF field events in case of p2p + UINT8 nfa_disable_rf_events[] = { 0x00 }; + ALOGD ("%s: Disabling RF field events", __FUNCTION__); + status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO, sizeof(nfa_disable_rf_events), + &nfa_disable_rf_events[0]); + if (status == NFA_STATUS_OK) { + ALOGD ("%s: Disabled RF field events", __FUNCTION__); + } else { + ALOGE ("%s: Failed to disable RF field events", __FUNCTION__); + } + } + else if (pn544InteropIsBusy() == false) + { + NfcTag::getInstance().connectionEventHandler (connEvent, eventData); + + // We know it is not activating for P2P. If it activated in + // listen mode then it is likely for and SE transaction. + // Send the RF Event. + if (isListenMode(eventData->activated)) + { + sSeRfActive = true; + SecureElement::getInstance().notifyListenModeState (true); + } + } + + break; + + case NFA_DEACTIVATED_EVT: // NFC link/protocol deactivated + ALOGD("%s: NFA_DEACTIVATED_EVT Type: %u, gIsTagDeactivating: %d", __FUNCTION__, eventData->deactivated.type,gIsTagDeactivating); + NfcTag::getInstance().setDeactivationState (eventData->deactivated); + if (eventData->deactivated.type != NFA_DEACTIVATE_TYPE_SLEEP) + { + nativeNfcTag_resetPresenceCheck(); + NfcTag::getInstance().connectionEventHandler (connEvent, eventData); + nativeNfcTag_abortWaits(); + NfcTag::getInstance().abort (); + } + else if (gIsTagDeactivating) + { + nativeNfcTag_doDeactivateStatus(0); + } + + // If RF is activated for what we think is a Secure Element transaction + // and it is deactivated to either IDLE or DISCOVERY mode, notify w/event. + if ((eventData->deactivated.type == NFA_DEACTIVATE_TYPE_IDLE) + || (eventData->deactivated.type == NFA_DEACTIVATE_TYPE_DISCOVERY)) + { + if (sSeRfActive) { + sSeRfActive = false; + SecureElement::getInstance().notifyListenModeState (false); + } else if (sP2pActive) { + sP2pActive = false; + // Make sure RF field events are re-enabled + ALOGD("%s: NFA_ACTIVATED_EVT; is p2p", __FUNCTION__); + // Disable RF field events in case of p2p + UINT8 nfa_enable_rf_events[] = { 0x01 }; + + ALOGD ("%s: Enabling RF field events", __FUNCTION__); + status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO, sizeof(nfa_enable_rf_events), + &nfa_enable_rf_events[0]); + if (status == NFA_STATUS_OK) { + ALOGD ("%s: Enabled RF field events", __FUNCTION__); + } else { + ALOGE ("%s: Failed to enable RF field events", __FUNCTION__); + } + } + } + + break; + + case NFA_TLV_DETECT_EVT: // TLV Detection complete + status = eventData->tlv_detect.status; + ALOGD("%s: NFA_TLV_DETECT_EVT: status = %d, protocol = %d, num_tlvs = %d, num_bytes = %d", + __FUNCTION__, status, eventData->tlv_detect.protocol, + eventData->tlv_detect.num_tlvs, eventData->tlv_detect.num_bytes); + if (status != NFA_STATUS_OK) + { + ALOGE("%s: NFA_TLV_DETECT_EVT error: status = %d", __FUNCTION__, status); + } + break; + + case NFA_NDEF_DETECT_EVT: // NDEF Detection complete; + //if status is failure, it means the tag does not contain any or valid NDEF data; + //pass the failure status to the NFC Service; + status = eventData->ndef_detect.status; + ALOGD("%s: NFA_NDEF_DETECT_EVT: status = 0x%X, protocol = %u, " + "max_size = %lu, cur_size = %lu, flags = 0x%X", __FUNCTION__, + status, + eventData->ndef_detect.protocol, eventData->ndef_detect.max_size, + eventData->ndef_detect.cur_size, eventData->ndef_detect.flags); + NfcTag::getInstance().connectionEventHandler (connEvent, eventData); + nativeNfcTag_doCheckNdefResult(status, + eventData->ndef_detect.max_size, eventData->ndef_detect.cur_size, + eventData->ndef_detect.flags); + break; + + case NFA_DATA_EVT: // Data message received (for non-NDEF reads) + ALOGD("%s: NFA_DATA_EVT: len = %d", __FUNCTION__, eventData->data.len); + nativeNfcTag_doTransceiveStatus(eventData->data.p_data,eventData->data.len); + break; + + case NFA_SELECT_CPLT_EVT: // Select completed + status = eventData->status; + ALOGD("%s: NFA_SELECT_CPLT_EVT: status = %d", __FUNCTION__, status); + if (status != NFA_STATUS_OK) + { + ALOGE("%s: NFA_SELECT_CPLT_EVT error: status = %d", __FUNCTION__, status); + } + break; + + case NFA_READ_CPLT_EVT: // NDEF-read or tag-specific-read completed + ALOGD("%s: NFA_READ_CPLT_EVT: status = 0x%X", __FUNCTION__, eventData->status); + nativeNfcTag_doReadCompleted (eventData->status); + NfcTag::getInstance().connectionEventHandler (connEvent, eventData); + break; + + case NFA_WRITE_CPLT_EVT: // Write completed + ALOGD("%s: NFA_WRITE_CPLT_EVT: status = %d", __FUNCTION__, eventData->status); + nativeNfcTag_doWriteStatus (eventData->status == NFA_STATUS_OK); + break; + + case NFA_SET_TAG_RO_EVT: // Tag set as Read only + ALOGD("%s: NFA_SET_TAG_RO_EVT: status = %d", __FUNCTION__, eventData->status); + nativeNfcTag_doMakeReadonlyResult(eventData->status); + break; + + case NFA_CE_NDEF_WRITE_START_EVT: // NDEF write started + ALOGD("%s: NFA_CE_NDEF_WRITE_START_EVT: status: %d", __FUNCTION__, eventData->status); + + if (eventData->status != NFA_STATUS_OK) + ALOGE("%s: NFA_CE_NDEF_WRITE_START_EVT error: status = %d", __FUNCTION__, eventData->status); + break; + + case NFA_CE_NDEF_WRITE_CPLT_EVT: // NDEF write completed + ALOGD("%s: FA_CE_NDEF_WRITE_CPLT_EVT: len = %lu", __FUNCTION__, eventData->ndef_write_cplt.len); + break; + + case NFA_LLCP_ACTIVATED_EVT: // LLCP link is activated + ALOGD("%s: NFA_LLCP_ACTIVATED_EVT: is_initiator: %d remote_wks: %d, remote_lsc: %d, remote_link_miu: %d, local_link_miu: %d", + __FUNCTION__, + eventData->llcp_activated.is_initiator, + eventData->llcp_activated.remote_wks, + eventData->llcp_activated.remote_lsc, + eventData->llcp_activated.remote_link_miu, + eventData->llcp_activated.local_link_miu); + + PeerToPeer::getInstance().llcpActivatedHandler (getNative(0, 0), eventData->llcp_activated); + break; + + case NFA_LLCP_DEACTIVATED_EVT: // LLCP link is deactivated + ALOGD("%s: NFA_LLCP_DEACTIVATED_EVT", __FUNCTION__); + PeerToPeer::getInstance().llcpDeactivatedHandler (getNative(0, 0), eventData->llcp_deactivated); + break; + + case NFA_PRESENCE_CHECK_EVT: + ALOGD("%s: NFA_PRESENCE_CHECK_EVT", __FUNCTION__); + nativeNfcTag_doPresenceCheckResult (eventData->status); + break; + + case NFA_FORMAT_CPLT_EVT: + ALOGD("%s: NFA_FORMAT_CPLT_EVT: status=0x%X", __FUNCTION__, eventData->status); + nativeNfcTag_formatStatus (eventData->status == NFA_STATUS_OK); + break; + + case NFA_I93_CMD_CPLT_EVT: + ALOGD("%s: NFA_I93_CMD_CPLT_EVT: status=0x%X", __FUNCTION__, eventData->status); + break; + + case NFA_CE_UICC_LISTEN_CONFIGURED_EVT : + ALOGD("%s: NFA_CE_UICC_LISTEN_CONFIGURED_EVT : status=0x%X", __FUNCTION__, eventData->status); + SecureElement::getInstance().connectionEventHandler (connEvent, eventData); + break; + + case NFA_SET_P2P_LISTEN_TECH_EVT: + ALOGD("%s: NFA_SET_P2P_LISTEN_TECH_EVT", __FUNCTION__); + PeerToPeer::getInstance().connectionEventHandler (connEvent, eventData); + break; + + default: + ALOGE("%s: unknown event ????", __FUNCTION__); + break; + } +} + + +/******************************************************************************* +** +** Function: nfcManager_initNativeStruc +** +** Description: Initialize variables. +** e: JVM environment. +** o: Java object. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nfcManager_initNativeStruc (JNIEnv* e, jobject o) +{ + nfc_jni_native_data* nat = NULL; + jclass cls = NULL; + jobject obj = NULL; + jfieldID f = 0; + + ALOGD ("%s: enter", __FUNCTION__); + + nat = (nfc_jni_native_data*)malloc(sizeof(struct nfc_jni_native_data)); + if (nat == NULL) + { + ALOGE ("%s: fail allocate native data", __FUNCTION__); + return JNI_FALSE; + } + + memset (nat, 0, sizeof(*nat)); + e->GetJavaVM (&(nat->vm)); + nat->env_version = e->GetVersion (); + nat->manager = e->NewGlobalRef (o); + + cls = e->GetObjectClass (o); + f = e->GetFieldID (cls, "mNative", "I"); + e->SetIntField (o, f, (jint)nat); + + /* Initialize native cached references */ + gCachedNfcManagerNotifyNdefMessageListeners = e->GetMethodID (cls, + "notifyNdefMessageListeners", "(Lcom/android/nfc/dhimpl/NativeNfcTag;)V"); + gCachedNfcManagerNotifyTransactionListeners = e->GetMethodID (cls, + "notifyTransactionListeners", "([B)V"); + gCachedNfcManagerNotifyLlcpLinkActivation = e->GetMethodID (cls, + "notifyLlcpLinkActivation", "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V"); + gCachedNfcManagerNotifyLlcpLinkDeactivated = e->GetMethodID (cls, + "notifyLlcpLinkDeactivated", "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V"); + sCachedNfcManagerNotifyTargetDeselected = e->GetMethodID (cls, + "notifyTargetDeselected","()V"); + gCachedNfcManagerNotifySeFieldActivated = e->GetMethodID (cls, + "notifySeFieldActivated", "()V"); + gCachedNfcManagerNotifySeFieldDeactivated = e->GetMethodID (cls, + "notifySeFieldDeactivated", "()V"); + gCachedNfcManagerNotifySeListenActivated = e->GetMethodID (cls, + "notifySeListenActivated", "()V"); + gCachedNfcManagerNotifySeListenDeactivated = e->GetMethodID (cls, + "notifySeListenDeactivated", "()V"); + + sCachedNfcManagerNotifySeApduReceived = e->GetMethodID(cls, + "notifySeApduReceived", "([B)V"); + + sCachedNfcManagerNotifySeMifareAccess = e->GetMethodID(cls, + "notifySeMifareAccess", "([B)V"); + + sCachedNfcManagerNotifySeEmvCardRemoval = e->GetMethodID(cls, + "notifySeEmvCardRemoval", "()V"); + + if (nfc_jni_cache_object(e,gNativeNfcTagClassName, &(nat->cached_NfcTag)) == -1) + { + ALOGE ("%s: fail cache NativeNfcTag", __FUNCTION__); + return JNI_FALSE; + } + + if (nfc_jni_cache_object(e,gNativeP2pDeviceClassName, &(nat->cached_P2pDevice)) == -1) + { + ALOGE ("%s: fail cache NativeP2pDevice", __FUNCTION__); + return JNI_FALSE; + } + + ALOGD ("%s: exit", __FUNCTION__); + return JNI_TRUE; +} + + +/******************************************************************************* +** +** Function: nfaDeviceManagementCallback +** +** Description: Receive device management events from stack. +** dmEvent: Device-management event ID. +** eventData: Data associated with event ID. +** +** Returns: None +** +*******************************************************************************/ +void nfaDeviceManagementCallback (UINT8 dmEvent, tNFA_DM_CBACK_DATA* eventData) +{ + ALOGD ("%s: enter; event=0x%X", __FUNCTION__, dmEvent); + + switch (dmEvent) + { + case NFA_DM_ENABLE_EVT: /* Result of NFA_Enable */ + { + SyncEventGuard guard (sNfaEnableEvent); + ALOGD ("%s: NFA_DM_ENABLE_EVT; status=0x%X", + __FUNCTION__, eventData->status); + sIsNfaEnabled = eventData->status == NFA_STATUS_OK; + sIsDisabling = false; + sNfaEnableEvent.notifyOne (); + } + break; + + case NFA_DM_DISABLE_EVT: /* Result of NFA_Disable */ + { + SyncEventGuard guard (sNfaDisableEvent); + ALOGD ("%s: NFA_DM_DISABLE_EVT", __FUNCTION__); + sIsNfaEnabled = false; + sIsDisabling = false; + sNfaDisableEvent.notifyOne (); + } + break; + + case NFA_DM_SET_CONFIG_EVT: //result of NFA_SetConfig + ALOGD ("%s: NFA_DM_SET_CONFIG_EVT", __FUNCTION__); + { + SyncEventGuard guard (sNfaSetConfigEvent); + sNfaSetConfigEvent.notifyOne(); + } + break; + + case NFA_DM_GET_CONFIG_EVT: /* Result of NFA_GetConfig */ + ALOGD ("%s: NFA_DM_GET_CONFIG_EVT", __FUNCTION__); + break; + + case NFA_DM_RF_FIELD_EVT: + ALOGD ("%s: NFA_DM_RF_FIELD_EVT; status=0x%X; field status=%u", __FUNCTION__, + eventData->rf_field.status, eventData->rf_field.rf_field_status); + + if (!sIsDisabling && eventData->rf_field.status == NFA_STATUS_OK) + SecureElement::getInstance().notifyRfFieldEvent (eventData->rf_field.rf_field_status == NFA_DM_RF_FIELD_ON); + break; + + case NFA_DM_NFCC_TRANSPORT_ERR_EVT: + case NFA_DM_NFCC_TIMEOUT_EVT: + { + if (dmEvent == NFA_DM_NFCC_TIMEOUT_EVT) + ALOGD ("%s: NFA_DM_NFCC_TIMEOUT_EVT; abort all outstanding operations", __FUNCTION__); + else + ALOGD ("%s: NFA_DM_NFCC_TRANSPORT_ERR_EVT; abort all outstanding operations", __FUNCTION__); + + nativeNfcTag_abortWaits(); + NfcTag::getInstance().abort (); + sAbortConnlessWait = true; + nativeLlcpConnectionlessSocket_abortWait(); + { + ALOGD ("%s: aborting sNfaEnableDisablePollingEvent", __FUNCTION__); + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + sNfaEnableDisablePollingEvent.notifyOne(); + } + { + ALOGD ("%s: aborting sNfaEnableEvent", __FUNCTION__); + SyncEventGuard guard (sNfaEnableEvent); + sNfaEnableEvent.notifyOne(); + } + { + ALOGD ("%s: aborting sNfaDisableEvent", __FUNCTION__); + SyncEventGuard guard (sNfaDisableEvent); + sNfaDisableEvent.notifyOne(); + } + sDiscoveryEnabled = false; + PowerSwitch::getInstance ().abort (); + + if (!sIsDisabling && sIsNfaEnabled) + { + NFA_Disable(FALSE); + sIsDisabling = true; + } + else + { + sIsNfaEnabled = false; + sIsDisabling = false; + } + PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL); + ALOGD ("%s: aborted all waiting events", __FUNCTION__); + } + break; + + case NFA_DM_PWR_MODE_CHANGE_EVT: + PowerSwitch::getInstance ().deviceManagementCallback (dmEvent, eventData); + break; + + default: + ALOGD ("%s: unhandled event", __FUNCTION__); + break; + } +} + + +/******************************************************************************* +** +** Function: nfcManager_doInitialize +** +** Description: Turn on NFC. +** e: JVM environment. +** o: Java object. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o) +{ + ALOGD ("%s: enter; NCI_VERSION=0x%02X", __FUNCTION__, NCI_VERSION); + tNFA_STATUS stat = NFA_STATUS_OK; + + if (sIsNfaEnabled) + { + ALOGD ("%s: already enabled", __FUNCTION__); + goto TheEnd; + } + + PowerSwitch::getInstance ().initialize (PowerSwitch::FULL_POWER); + + { + unsigned long num = 0; + + NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); + theInstance.Initialize(); //start GKI, NCI task, NFC task + + { + SyncEventGuard guard (sNfaEnableEvent); + tHAL_NFC_ENTRY* halFuncEntries = theInstance.GetHalEntryFuncs (); + + NFA_Init (halFuncEntries); + + stat = NFA_Enable (nfaDeviceManagementCallback, nfaConnectionCallback); + if (stat == NFA_STATUS_OK) + { + num = initializeGlobalAppLogLevel (); + CE_SetTraceLevel (num); + LLCP_SetTraceLevel (num); + NFC_SetTraceLevel (num); + RW_SetTraceLevel (num); + NFA_SetTraceLevel (num); + NFA_ChoSetTraceLevel (num); + NFA_P2pSetTraceLevel (num); + NFA_SnepSetTraceLevel (num); + sNfaEnableEvent.wait(); //wait for NFA command to finish + } + } + + if (stat == NFA_STATUS_OK) + { + //sIsNfaEnabled indicates whether stack started successfully + if (sIsNfaEnabled) + { + SecureElement::getInstance().initialize (getNative(e, o)); + nativeNfcTag_registerNdefTypeHandler (); + NfcTag::getInstance().initialize (getNative(e, o)); + PeerToPeer::getInstance().initialize (); + PeerToPeer::getInstance().handleNfcOnOff (true); + + ///////////////////////////////////////////////////////////////////////////////// + // Add extra configuration here (work-arounds, etc.) + + struct nfc_jni_native_data *nat = getNative(e, o); + + if ( nat ) + { + if (GetNumValue(NAME_POLLING_TECH_MASK, &num, sizeof(num))) + nat->tech_mask = num; + else + nat->tech_mask = DEFAULT_TECH_MASK; + + ALOGD ("%s: tag polling tech mask=0x%X", __FUNCTION__, nat->tech_mask); + } + + // Always restore LPTD Configuration to the stack default. + if (sOriginalLptdCfg != NULL) + p_nfa_dm_lptd_cfg = sOriginalLptdCfg; + + // if this value exists, set polling interval. + if (GetNumValue(NAME_NFA_DM_DISC_DURATION_POLL, &num, sizeof(num))) + NFA_SetRfDiscoveryDuration(num); + + // Do custom NFCA startup configuration. + doStartupConfig(); + goto TheEnd; + } + } + + ALOGE ("%s: fail nfa enable; error=0x%X", __FUNCTION__, stat); + + if (sIsNfaEnabled) + stat = NFA_Disable (FALSE /* ungraceful */); + + theInstance.Finalize(); + } + +TheEnd: + if (sIsNfaEnabled) + PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); + ALOGD ("%s: exit", __FUNCTION__); + return sIsNfaEnabled ? JNI_TRUE : JNI_FALSE; +} + + +/******************************************************************************* +** +** Function: nfcManager_enableDiscovery +** +** Description: Start polling and listening for devices. +** e: JVM environment. +** o: Java object. +** mode: Not used. +** +** Returns: None +** +*******************************************************************************/ +static void nfcManager_enableDiscovery (JNIEnv* e, jobject o) +{ + tNFA_TECHNOLOGY_MASK tech_mask = DEFAULT_TECH_MASK; + struct nfc_jni_native_data *nat = getNative(e, o); + + if (nat) + tech_mask = (tNFA_TECHNOLOGY_MASK)nat->tech_mask; + + ALOGD ("%s: enter; tech_mask = %02x", __FUNCTION__, tech_mask); + + if (sDiscoveryEnabled) + { + ALOGE ("%s: already polling", __FUNCTION__); + return; + } + + tNFA_STATUS stat = NFA_STATUS_OK; + + ALOGD ("%s: sIsSecElemSelected=%u", __FUNCTION__, sIsSecElemSelected); + + PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); + + if (sRfEnabled) { + // Stop RF discovery to reconfigure + startRfDiscovery(false); + } + + { + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + stat = NFA_EnablePolling (tech_mask); + if (stat == NFA_STATUS_OK) + { + ALOGD ("%s: wait for enable event", __FUNCTION__); + sDiscoveryEnabled = true; + sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT + ALOGD ("%s: got enabled event", __FUNCTION__); + } + else + { + ALOGE ("%s: fail enable discovery; error=0x%X", __FUNCTION__, stat); + } + } + + // Start P2P listening if tag polling was enabled or the mask was 0. + if (sDiscoveryEnabled || (tech_mask == 0)) + { + ALOGD ("%s: Enable p2pListening", __FUNCTION__); + PeerToPeer::getInstance().enableP2pListening (true); + + //if NFC service has deselected the sec elem, then apply default routes + if (!sIsSecElemSelected) + stat = SecureElement::getInstance().routeToDefault (); + } + + // Actually start discovery. + startRfDiscovery (true); + + PowerSwitch::getInstance ().setModeOn (PowerSwitch::DISCOVERY); + + ALOGD ("%s: exit", __FUNCTION__); +} + + +/******************************************************************************* +** +** Function: nfcManager_disableDiscovery +** +** Description: Stop polling and listening for devices. +** e: JVM environment. +** o: Java object. +** +** Returns: None +** +*******************************************************************************/ +void nfcManager_disableDiscovery (JNIEnv* e, jobject o) +{ + tNFA_STATUS status = NFA_STATUS_OK; + ALOGD ("%s: enter;", __FUNCTION__); + + pn544InteropAbortNow (); + if (sDiscoveryEnabled == false) + { + ALOGD ("%s: already disabled", __FUNCTION__); + goto TheEnd; + } + + // Stop RF Discovery. + startRfDiscovery (false); + + if (sDiscoveryEnabled) + { + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + status = NFA_DisablePolling (); + if (status == NFA_STATUS_OK) + { + sDiscoveryEnabled = false; + sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT + } + else + ALOGE ("%s: Failed to disable polling; error=0x%X", __FUNCTION__, status); + } + + PeerToPeer::getInstance().enableP2pListening (false); + + //if nothing is active after this, then tell the controller to power down + if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::DISCOVERY)) + PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); + +TheEnd: + ALOGD ("%s: exit", __FUNCTION__); +} + +/******************************************************************************* +** +** Function nfc_jni_cache_object_local +** +** Description Allocates a java object and calls it's constructor +** +** Returns -1 on failure, 0 on success +** +*******************************************************************************/ +int nfc_jni_cache_object_local (JNIEnv *e, const char *className, jobject *cachedObj) +{ + jclass cls = NULL; + jobject obj = NULL; + jmethodID ctor = 0; + + cls = e->FindClass (className); + if(cls == NULL) + { + ALOGE ("%s: find class error", __FUNCTION__); + return -1; + } + + ctor = e->GetMethodID (cls, "", "()V"); + obj = e->NewObject (cls, ctor); + if (obj == NULL) + { + ALOGE ("%s: create object error", __FUNCTION__); + return -1; + } + + *cachedObj = e->NewLocalRef (obj); + if (*cachedObj == NULL) + { + e->DeleteLocalRef (obj); + ALOGE ("%s: global ref error", __FUNCTION__); + return -1; + } + e->DeleteLocalRef (obj); + return 0; +} + + +/******************************************************************************* +** +** Function: nfcManager_doCreateLlcpServiceSocket +** +** Description: Create a new LLCP server socket. +** e: JVM environment. +** o: Java object. +** nSap: Service access point. +** sn: Service name +** miu: Maximum information unit. +** rw: Receive window size. +** linearBufferLength: Max buffer size. +** +** Returns: NativeLlcpServiceSocket Java object. +** +*******************************************************************************/ +static jobject nfcManager_doCreateLlcpServiceSocket (JNIEnv* e, jobject o, jint nSap, jstring sn, jint miu, jint rw, jint linearBufferLength) +{ + bool stat = false; + jobject serviceSocket = NULL; + jclass clsNativeLlcpServiceSocket = NULL; + jfieldID f = 0; + PeerToPeer::tJNI_HANDLE jniHandle = PeerToPeer::getInstance().getNewJniHandle (); + const char* serviceName = e->GetStringUTFChars (sn, JNI_FALSE); //convert jstring, which is unicode, into char* + std::string serviceName2 (serviceName); + + e->ReleaseStringUTFChars (sn, serviceName); //free the string + ALOGD ("%s: enter: sap=%i; name=%s; miu=%i; rw=%i; buffLen=%i", __FUNCTION__, nSap, serviceName2.c_str(), miu, rw, linearBufferLength); + + /* Create new NativeLlcpServiceSocket object */ + if (nfc_jni_cache_object(e, gNativeLlcpServiceSocketClassName, &(serviceSocket)) == -1) + { + ALOGE ("%s: Llcp socket object creation error", __FUNCTION__); + return NULL; + } + + /* Get NativeLlcpServiceSocket class object */ + clsNativeLlcpServiceSocket = e->GetObjectClass (serviceSocket); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE("%s: Llcp Socket get object class error", __FUNCTION__); + return NULL; + } + + if (!PeerToPeer::getInstance().registerServer (jniHandle, serviceName2.c_str())) + { + ALOGE("%s: RegisterServer error", __FUNCTION__); + return NULL; + } + + /* Set socket handle to be the same as the NfaHandle*/ + f = e->GetFieldID (clsNativeLlcpServiceSocket, "mHandle", "I"); + e->SetIntField (serviceSocket, f, (jint) jniHandle); + ALOGD ("%s: socket Handle = 0x%X", __FUNCTION__, jniHandle); + + /* Set socket linear buffer length */ + f = e->GetFieldID (clsNativeLlcpServiceSocket, "mLocalLinearBufferLength", "I"); + e->SetIntField (serviceSocket, f,(jint)linearBufferLength); + ALOGD ("%s: buffer length = %d", __FUNCTION__, linearBufferLength); + + /* Set socket MIU */ + f = e->GetFieldID (clsNativeLlcpServiceSocket, "mLocalMiu", "I"); + e->SetIntField (serviceSocket, f,(jint)miu); + ALOGD ("%s: MIU = %d", __FUNCTION__, miu); + + /* Set socket RW */ + f = e->GetFieldID (clsNativeLlcpServiceSocket, "mLocalRw", "I"); + e->SetIntField (serviceSocket, f,(jint)rw); + ALOGD ("%s: RW = %d", __FUNCTION__, rw); + + sLastError = 0; + ALOGD ("%s: exit", __FUNCTION__); + return serviceSocket; +} + + +/******************************************************************************* +** +** Function: nfcManager_doGetLastError +** +** Description: Get the last error code. +** e: JVM environment. +** o: Java object. +** +** Returns: Last error code. +** +*******************************************************************************/ +static jint nfcManager_doGetLastError(JNIEnv* e, jobject o) +{ + ALOGD ("%s: last error=%i", __FUNCTION__, sLastError); + return sLastError; +} + + +/******************************************************************************* +** +** Function: nfcManager_doDeinitialize +** +** Description: Turn off NFC. +** e: JVM environment. +** o: Java object. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nfcManager_doDeinitialize (JNIEnv* e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + + sIsDisabling = true; + pn544InteropAbortNow (); + SecureElement::getInstance().finalize (); + + if (sIsNfaEnabled) + { + SyncEventGuard guard (sNfaDisableEvent); + tNFA_STATUS stat = NFA_Disable (TRUE /* graceful */); + if (stat == NFA_STATUS_OK) + { + ALOGD ("%s: wait for completion", __FUNCTION__); + sNfaDisableEvent.wait (); //wait for NFA command to finish + PeerToPeer::getInstance ().handleNfcOnOff (false); + } + else + { + ALOGE ("%s: fail disable; error=0x%X", __FUNCTION__, stat); + } + } + nativeNfcTag_abortWaits(); + NfcTag::getInstance().abort (); + sAbortConnlessWait = true; + nativeLlcpConnectionlessSocket_abortWait(); + sIsNfaEnabled = false; + sDiscoveryEnabled = false; + sIsDisabling = false; + sIsSecElemSelected = false; + + { + //unblock NFA_EnablePolling() and NFA_DisablePolling() + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + sNfaEnableDisablePollingEvent.notifyOne (); + } + + NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); + theInstance.Finalize(); + + ALOGD ("%s: exit", __FUNCTION__); + return JNI_TRUE; +} + + +/******************************************************************************* +** +** Function: nfcManager_doCreateLlcpSocket +** +** Description: Create a LLCP connection-oriented socket. +** e: JVM environment. +** o: Java object. +** nSap: Service access point. +** miu: Maximum information unit. +** rw: Receive window size. +** linearBufferLength: Max buffer size. +** +** Returns: NativeLlcpSocket Java object. +** +*******************************************************************************/ +static jobject nfcManager_doCreateLlcpSocket (JNIEnv* e, jobject o, jint nSap, jint miu, jint rw, jint linearBufferLength) +{ + ALOGD ("%s: enter; sap=%d; miu=%d; rw=%d; buffer len=%d", __FUNCTION__, nSap, miu, rw, linearBufferLength); + jobject clientSocket = NULL; + jclass clsNativeLlcpSocket; + jfieldID f; + PeerToPeer::tJNI_HANDLE jniHandle = PeerToPeer::getInstance().getNewJniHandle (); + bool stat = false; + + stat = PeerToPeer::getInstance().createClient (jniHandle, miu, rw); + + /* Create new NativeLlcpSocket object */ + if (nfc_jni_cache_object_local(e, gNativeLlcpSocketClassName, &(clientSocket)) == -1) + { + ALOGE ("%s: fail Llcp socket creation", __FUNCTION__); + goto TheEnd; + } + + /* Get NativeConnectionless class object */ + clsNativeLlcpSocket = e->GetObjectClass (clientSocket); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail get class object", __FUNCTION__); + goto TheEnd; + } + + /* Set socket SAP */ + f = e->GetFieldID (clsNativeLlcpSocket, "mSap", "I"); + e->SetIntField (clientSocket, f, (jint) nSap); + + /* Set socket handle */ + f = e->GetFieldID (clsNativeLlcpSocket, "mHandle", "I"); + e->SetIntField (clientSocket, f, (jint) jniHandle); + + /* Set socket MIU */ + f = e->GetFieldID (clsNativeLlcpSocket, "mLocalMiu", "I"); + e->SetIntField (clientSocket, f, (jint) miu); + + /* Set socket RW */ + f = e->GetFieldID (clsNativeLlcpSocket, "mLocalRw", "I"); + e->SetIntField (clientSocket, f, (jint) rw); + +TheEnd: + ALOGD ("%s: exit", __FUNCTION__); + return clientSocket; +} + + +/******************************************************************************* +** +** Function: nfcManager_doCreateLlcpConnectionlessSocket +** +** Description: Create a connection-less socket. +** e: JVM environment. +** o: Java object. +** nSap: Service access point. +** sn: Service name. +** +** Returns: NativeLlcpConnectionlessSocket Java object. +** +*******************************************************************************/ +static jobject nfcManager_doCreateLlcpConnectionlessSocket (JNIEnv *e, jobject o, jint nSap, jstring sn) +{ + ALOGD ("%s: nSap=0x%X", __FUNCTION__, nSap); + return NULL; +} + + +/******************************************************************************* +** +** Function: nfcManager_doGetSecureElementList +** +** Description: Get a list of secure element handles. +** e: JVM environment. +** o: Java object. +** +** Returns: List of secure element handles. +** +*******************************************************************************/ +static jintArray nfcManager_doGetSecureElementList(JNIEnv *e, jobject o) +{ + ALOGD ("%s", __FUNCTION__); + return SecureElement::getInstance().getListOfEeHandles (e); +} + + +/******************************************************************************* +** +** Function: nfcManager_doSelectSecureElement +** +** Description: NFC controller starts routing data in listen mode. +** e: JVM environment. +** o: Java object. +** +** Returns: None +** +*******************************************************************************/ +static void nfcManager_doSelectSecureElement(JNIEnv *e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + bool stat = true; + + PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); + + if (sRfEnabled) { + // Stop RF Discovery if we were polling + startRfDiscovery (false); + } + + if (sIsSecElemSelected) + { + ALOGD ("%s: already selected", __FUNCTION__); + goto TheEnd; + } + + stat = SecureElement::getInstance().activate (0xABCDEF); + if (stat) + SecureElement::getInstance().routeToSecureElement (); + sIsSecElemSelected = true; + +TheEnd: + startRfDiscovery (true); + + PowerSwitch::getInstance ().setModeOn (PowerSwitch::SE_ROUTING); + + ALOGD ("%s: exit", __FUNCTION__); +} + + +/******************************************************************************* +** +** Function: nfcManager_doDeselectSecureElement +** +** Description: NFC controller stops routing data in listen mode. +** e: JVM environment. +** o: Java object. +** +** Returns: None +** +*******************************************************************************/ +static void nfcManager_doDeselectSecureElement(JNIEnv *e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + bool stat = false; + + if (! sIsSecElemSelected) + { + ALOGE ("%s: already deselected", __FUNCTION__); + goto TheEnd; + } + + if (PowerSwitch::getInstance ().getLevel() == PowerSwitch::LOW_POWER) + { + ALOGD ("%s: do not deselect while power is OFF", __FUNCTION__); + sIsSecElemSelected = false; + goto TheEnd; + } + + stat = SecureElement::getInstance().routeToDefault (); + sIsSecElemSelected = false; + + //if controller is not routing to sec elems AND there is no pipe connected, + //then turn off the sec elems + if (SecureElement::getInstance().isBusy() == false) + SecureElement::getInstance().deactivate (0xABCDEF); + +TheEnd: + //if nothing is active after this, then tell the controller to power down + if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::SE_ROUTING)) + PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); + + ALOGD ("%s: exit", __FUNCTION__); +} + + +/******************************************************************************* +** +** Function: isPeerToPeer +** +** Description: Whether the activation data indicates the peer supports NFC-DEP. +** activated: Activation data. +** +** Returns: True if the peer supports NFC-DEP. +** +*******************************************************************************/ +static bool isPeerToPeer (tNFA_ACTIVATED& activated) +{ + return activated.activate_ntf.protocol == NFA_PROTOCOL_NFC_DEP; +} + +/******************************************************************************* +** +** Function: isListenMode +** +** Description: Indicates whether the activation data indicates it is +** listen mode. +** +** Returns: True if this listen mode. +** +*******************************************************************************/ +static bool isListenMode(tNFA_ACTIVATED& activated) +{ + return ((NFC_DISCOVERY_TYPE_LISTEN_A == activated.activate_ntf.rf_tech_param.mode) + || (NFC_DISCOVERY_TYPE_LISTEN_B == activated.activate_ntf.rf_tech_param.mode) + || (NFC_DISCOVERY_TYPE_LISTEN_F == activated.activate_ntf.rf_tech_param.mode) + || (NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == activated.activate_ntf.rf_tech_param.mode) + || (NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == activated.activate_ntf.rf_tech_param.mode) + || (NFC_DISCOVERY_TYPE_LISTEN_ISO15693 == activated.activate_ntf.rf_tech_param.mode) + || (NFC_DISCOVERY_TYPE_LISTEN_B_PRIME == activated.activate_ntf.rf_tech_param.mode)); +} + +/******************************************************************************* +** +** Function: nfcManager_doCheckLlcp +** +** Description: Not used. +** +** Returns: True +** +*******************************************************************************/ +static jboolean nfcManager_doCheckLlcp(JNIEnv *e, jobject o) +{ + ALOGD("%s", __FUNCTION__); + return JNI_TRUE; +} + + +/******************************************************************************* +** +** Function: nfcManager_doActivateLlcp +** +** Description: Not used. +** +** Returns: True +** +*******************************************************************************/ +static jboolean nfcManager_doActivateLlcp(JNIEnv *e, jobject o) +{ + ALOGD("%s", __FUNCTION__); + return JNI_TRUE; +} + + +/******************************************************************************* +** +** Function: nfcManager_doAbort +** +** Description: Not used. +** +** Returns: None +** +*******************************************************************************/ +static void nfcManager_doAbort(JNIEnv *e, jobject o) +{ + ALOGE("%s: abort()", __FUNCTION__); + abort(); +} + + +/******************************************************************************* +** +** Function: nfcManager_doDownload +** +** Description: Not used. +** +** Returns: True +** +*******************************************************************************/ +static jboolean nfcManager_doDownload(JNIEnv *e, jobject o) +{ + ALOGD("%s", __FUNCTION__); + return JNI_TRUE; +} + + +/******************************************************************************* +** +** Function: nfcManager_doResetTimeouts +** +** Description: Not used. +** +** Returns: None +** +*******************************************************************************/ +static void nfcManager_doResetTimeouts(JNIEnv *e, jobject o) +{ + ALOGD ("%s: %d millisec", __FUNCTION__, DEFAULT_GENERAL_TRANS_TIMEOUT); + gGeneralTransceiveTimeout = DEFAULT_GENERAL_TRANS_TIMEOUT; +} + + +/******************************************************************************* +** +** Function: nfcManager_doSetTimeout +** +** Description: Set timeout value. +** e: JVM environment. +** o: Java object. +** timeout: Timeout value. +** +** Returns: True if ok. +** +*******************************************************************************/ +static bool nfcManager_doSetTimeout(JNIEnv *e, jobject o, jint tech, jint timeout) +{ + if (timeout <= 0) + { + ALOGE("%s: Timeout must be positive.",__FUNCTION__); + return false; + } + + ALOGD ("%s: timeout=%d", __FUNCTION__, timeout); + gGeneralTransceiveTimeout = timeout; + return true; +} + + +/******************************************************************************* +** +** Function: nfcManager_doGetTimeout +** +** Description: Get timeout value. +** e: JVM environment. +** o: Java object. +** tech: Not used. +** +** Returns: Timeout value. +** +*******************************************************************************/ +static jint nfcManager_doGetTimeout(JNIEnv *e, jobject o, jint tech) +{ + ALOGD ("%s: timeout=%d", __FUNCTION__, gGeneralTransceiveTimeout); + return gGeneralTransceiveTimeout; +} + + +/******************************************************************************* +** +** Function: nfcManager_doDump +** +** Description: Not used. +** e: JVM environment. +** o: Java object. +** +** Returns: Text dump. +** +*******************************************************************************/ +static jstring nfcManager_doDump(JNIEnv *e, jobject o) +{ + char buffer[100]; + snprintf(buffer, sizeof(buffer), "libnfc llc error_count=%u", /*libnfc_llc_error_count*/ 0); + return e->NewStringUTF(buffer); +} + + +/******************************************************************************* +** +** Function: nfcManager_doSetP2pInitiatorModes +** +** Description: Set P2P initiator's activation modes. +** e: JVM environment. +** o: Java object. +** modes: Active and/or passive modes. The values are specified +** in external/libnfc-nxp/inc/phNfcTypes.h. See +** enum phNfc_eP2PMode_t. +** +** Returns: None. +** +*******************************************************************************/ +static void nfcManager_doSetP2pInitiatorModes (JNIEnv *e, jobject o, jint modes) +{ + ALOGD ("%s: modes=0x%X", __FUNCTION__, modes); + struct nfc_jni_native_data *nat = getNative(e, o); + + tNFA_TECHNOLOGY_MASK mask = 0; + if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A; + if (modes & 0x02) mask |= NFA_TECHNOLOGY_MASK_F; + if (modes & 0x04) mask |= NFA_TECHNOLOGY_MASK_F; + if (modes & 0x08) mask |= NFA_TECHNOLOGY_MASK_A_ACTIVE; + if (modes & 0x10) mask |= NFA_TECHNOLOGY_MASK_F_ACTIVE; + if (modes & 0x20) mask |= NFA_TECHNOLOGY_MASK_F_ACTIVE; + nat->tech_mask = mask; + + //this function is not called by the NFC service nor exposed by public API. +} + + +/******************************************************************************* +** +** Function: nfcManager_doSetP2pTargetModes +** +** Description: Set P2P target's activation modes. +** e: JVM environment. +** o: Java object. +** modes: Active and/or passive modes. +** +** Returns: None. +** +*******************************************************************************/ +static void nfcManager_doSetP2pTargetModes (JNIEnv *e, jobject o, jint modes) +{ + ALOGD ("%s: modes=0x%X", __FUNCTION__, modes); + // Map in the right modes + tNFA_TECHNOLOGY_MASK mask = 0; + if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A; + if (modes & 0x02) mask |= NFA_TECHNOLOGY_MASK_F; + if (modes & 0x04) mask |= NFA_TECHNOLOGY_MASK_F; + if (modes & 0x08) mask |= NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE; + + PeerToPeer::getInstance().setP2pListenMask(mask); + //this function is not called by the NFC service nor exposed by public API. +} + +/***************************************************************************** +** +** JNI functions for android-4.0.1_r1 +** +*****************************************************************************/ +static JNINativeMethod gMethods[] = +{ + {"doDownload", "()Z", + (void *)nfcManager_doDownload}, + + {"initializeNativeStructure", "()Z", + (void*) nfcManager_initNativeStruc}, + + {"doInitialize", "()Z", + (void*) nfcManager_doInitialize}, + + {"doDeinitialize", "()Z", + (void*) nfcManager_doDeinitialize}, + + {"enableDiscovery", "()V", + (void*) nfcManager_enableDiscovery}, + + {"doGetSecureElementList", "()[I", + (void *)nfcManager_doGetSecureElementList}, + + {"doSelectSecureElement", "()V", + (void *)nfcManager_doSelectSecureElement}, + + {"doDeselectSecureElement", "()V", + (void *)nfcManager_doDeselectSecureElement}, + + {"doCheckLlcp", "()Z", + (void *)nfcManager_doCheckLlcp}, + + {"doActivateLlcp", "()Z", + (void *)nfcManager_doActivateLlcp}, + + {"doCreateLlcpConnectionlessSocket", "(ILjava/lang/String;)Lcom/android/nfc/dhimpl/NativeLlcpConnectionlessSocket;", + (void *)nfcManager_doCreateLlcpConnectionlessSocket}, + + {"doCreateLlcpServiceSocket", "(ILjava/lang/String;III)Lcom/android/nfc/dhimpl/NativeLlcpServiceSocket;", + (void*) nfcManager_doCreateLlcpServiceSocket}, + + {"doCreateLlcpSocket", "(IIII)Lcom/android/nfc/dhimpl/NativeLlcpSocket;", + (void*) nfcManager_doCreateLlcpSocket}, + + {"doGetLastError", "()I", + (void*) nfcManager_doGetLastError}, + + {"disableDiscovery", "()V", + (void*) nfcManager_disableDiscovery}, + + {"doSetTimeout", "(II)Z", + (void *)nfcManager_doSetTimeout}, + + {"doGetTimeout", "(I)I", + (void *)nfcManager_doGetTimeout}, + + {"doResetTimeouts", "()V", + (void *)nfcManager_doResetTimeouts}, + + {"doAbort", "()V", + (void *)nfcManager_doAbort}, + + {"doSetP2pInitiatorModes", "(I)V", + (void *)nfcManager_doSetP2pInitiatorModes}, + + {"doSetP2pTargetModes", "(I)V", + (void *)nfcManager_doSetP2pTargetModes}, + + {"doDump", "()Ljava/lang/String;", + (void *)nfcManager_doDump}, +}; + + +/******************************************************************************* +** +** Function: register_com_android_nfc_NativeNfcManager +** +** Description: Regisgter JNI functions with Java Virtual Machine. +** e: Environment of JVM. +** +** Returns: Status of registration. +** +*******************************************************************************/ +int register_com_android_nfc_NativeNfcManager (JNIEnv *e) +{ + ALOGD ("%s: enter", __FUNCTION__); + PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL); + ALOGD ("%s: exit", __FUNCTION__); + return jniRegisterNativeMethods (e, gNativeNfcManagerClassName, gMethods, NELEM (gMethods)); +} + + +/******************************************************************************* +** +** Function: startRfDiscovery +** +** Description: Ask stack to start polling and listening for devices. +** isStart: Whether to start. +** +** Returns: None +** +*******************************************************************************/ +void startRfDiscovery(bool isStart) +{ + tNFA_STATUS status = NFA_STATUS_FAILED; + + ALOGD ("%s: is start=%d", __FUNCTION__, isStart); + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + status = isStart ? NFA_StartRfDiscovery () : NFA_StopRfDiscovery (); + if (status == NFA_STATUS_OK) + { + sNfaEnableDisablePollingEvent.wait (); //wait for NFA_RF_DISCOVERY_xxxx_EVT + sRfEnabled = isStart; + } + else + { + ALOGE ("%s: Failed to start/stop RF discovery; error=0x%X", __FUNCTION__, status); + } +} + + +/******************************************************************************* +** +** Function: doStartupConfig +** +** Description: Configure the NFC controller. +** +** Returns: None +** +*******************************************************************************/ +void doStartupConfig() +{ + unsigned long num = 0; + struct nfc_jni_native_data *nat = getNative(0, 0); + tNFA_STATUS stat = NFA_STATUS_FAILED; + + // Enable the "RC workaround" to allow our stack/firmware to work with a retail + // Nexus S that causes IOP issues. Only enable if value exists and set to 1. + if (GetNumValue(NAME_USE_NXP_P2P_RC_WORKAROUND, &num, sizeof(num)) && (num == 1)) + { +#if (NCI_VERSION > NCI_VERSION_20791B0) + UINT8 nfa_dm_rc_workaround[] = { 0x03, 0x0f, 0xab }; +#else + UINT8 nfa_dm_rc_workaround[] = { 0x01, 0x0f, 0xab, 0x01 }; +#endif + + ALOGD ("%s: Configure RC work-around", __FUNCTION__); + SyncEventGuard guard (sNfaSetConfigEvent); + stat = NFA_SetConfig(NCI_PARAM_ID_FW_WORKAROUND, sizeof(nfa_dm_rc_workaround), &nfa_dm_rc_workaround[0]); + if (stat == NFA_STATUS_OK) + sNfaSetConfigEvent.wait (); + } + + // If polling for Active mode, set the ordering so that we choose Active over Passive mode first. + if (nat && (nat->tech_mask & (NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE))) + { + UINT8 act_mode_order_param[] = { 0x01 }; + SyncEventGuard guard (sNfaSetConfigEvent); + stat = NFA_SetConfig(NCI_PARAM_ID_ACT_ORDER, sizeof(act_mode_order_param), &act_mode_order_param[0]); + if (stat == NFA_STATUS_OK) + sNfaSetConfigEvent.wait (); + } + + // Set configuration to allow UICC to Power off if there is no traffic. + if (GetNumValue(NAME_UICC_IDLE_TIMEOUT, &num, sizeof(num)) && (num != 0)) + { + // 61 => The least significant bit of this byte enables the power off when Idle mode. + // 00 87 93 03 == > These 4 bytes form a 4 byte value which decides the idle timeout(in us) + // value to trigger the uicc deactivation. + // e.g. in current example its value is 0x3938700 i.e. 60000000 is 60 seconds. + UINT8 swpcfg_param[] = { 0x61, 0x00, 0x82, 0x04, 0x20, 0xA1, 0x07, 0x00, + 0x90, 0xD0, 0x03, 0x00, 0x00, 0x87, 0x93, 0x03 }; + + ALOGD ("%s: Configure UICC idle-timeout to %lu ms", __FUNCTION__, num); + + // Set the timeout from the .conf file value. + num *= 1000; + UINT8 * p = &swpcfg_param[12]; + UINT32_TO_STREAM(p, num) + + SyncEventGuard guard (sNfaSetConfigEvent); + stat = NFA_SetConfig(NCI_PARAM_ID_SWPCFG, sizeof(swpcfg_param), &swpcfg_param[0]); + if (stat == NFA_STATUS_OK) + sNfaSetConfigEvent.wait (); + } + + // Set antenna tuning configuration if configured. +#define PREINIT_DSP_CFG_SIZE 30 + UINT8 preinit_dsp_param[PREINIT_DSP_CFG_SIZE]; + + if (GetStrValue(NAME_PREINIT_DSP_CFG, (char*)&preinit_dsp_param[0], sizeof(preinit_dsp_param))) + { + SyncEventGuard guard (sNfaSetConfigEvent); + stat = NFA_SetConfig(NCI_PARAM_ID_PREINIT_DSP_CFG, sizeof(preinit_dsp_param), &preinit_dsp_param[0]); + if (stat == NFA_STATUS_OK) + sNfaSetConfigEvent.wait (); + } +} + + +/******************************************************************************* +** +** Function: nfcManager_isNfcActive +** +** Description: Used externaly to determine if NFC is active or not. +** +** Returns: 'true' if the NFC stack is running, else 'false'. +** +*******************************************************************************/ +bool nfcManager_isNfcActive() +{ + return sIsNfaEnabled; +} + + +/******************************************************************************* +** +** Function: startStopPolling +** +** Description: Start or stop polling. +** isStartPolling: true to start polling; false to stop polling. +** +** Returns: None. +** +*******************************************************************************/ +void startStopPolling (bool isStartPolling) +{ + ALOGD ("%s: enter; isStart=%u", __FUNCTION__, isStartPolling); + tNFA_STATUS stat = NFA_STATUS_FAILED; + + startRfDiscovery (false); + if (isStartPolling) + { + tNFA_TECHNOLOGY_MASK tech_mask = DEFAULT_TECH_MASK; + unsigned long num = 0; + if (GetNumValue(NAME_POLLING_TECH_MASK, &num, sizeof(num))) + tech_mask = num; + + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + ALOGD ("%s: enable polling", __FUNCTION__); + stat = NFA_EnablePolling (tech_mask); + if (stat == NFA_STATUS_OK) + { + ALOGD ("%s: wait for enable event", __FUNCTION__); + sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT + } + else + ALOGE ("%s: fail enable polling; error=0x%X", __FUNCTION__, stat); + } + else + { + SyncEventGuard guard (sNfaEnableDisablePollingEvent); + ALOGD ("%s: disable polling", __FUNCTION__); + stat = NFA_DisablePolling (); + if (stat == NFA_STATUS_OK) + { + sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT + } + else + ALOGE ("%s: fail disable polling; error=0x%X", __FUNCTION__, stat); + } + startRfDiscovery (true); + ALOGD ("%s: exit", __FUNCTION__); +} + + +} /* namespace android */ diff --git a/nci/jni/NativeNfcTag.cpp b/nci/jni/NativeNfcTag.cpp new file mode 100755 index 0000000..0ba7b21 --- /dev/null +++ b/nci/jni/NativeNfcTag.cpp @@ -0,0 +1,1507 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include "OverrideLog.h" +#include "NfcJniUtil.h" +#include "NfcTag.h" +#include "config.h" +#include "Mutex.h" +#include "IntervalTimer.h" +#include "JavaClassConstants.h" +#include "Pn544Interop.h" + +extern "C" +{ + #include "nfa_api.h" + #include "nfa_rw_api.h" + #include "ndef_utils.h" + #include "rw_api.h" +} +namespace android +{ + extern nfc_jni_native_data* getNative(JNIEnv *e, jobject o); + extern bool nfcManager_isNfcActive(); + extern int gGeneralTransceiveTimeout; +} + + +/***************************************************************************** +** +** public variables and functions +** +*****************************************************************************/ +namespace android +{ + bool gIsTagDeactivating = false; // flag for nfa callback indicating we are deactivating for RF interface switch + bool gIsSelectingRfInterface = false; // flag for nfa callback indicating we are selecting for RF interface switch +} + + +/***************************************************************************** +** +** private variables and functions +** +*****************************************************************************/ +namespace android +{ + + +// Pre-defined tag type values. These must match the values in +// framework Ndef.java for Google public NFC API. +#define NDEF_UNKNOWN_TYPE -1 +#define NDEF_TYPE1_TAG 1 +#define NDEF_TYPE2_TAG 2 +#define NDEF_TYPE3_TAG 3 +#define NDEF_TYPE4_TAG 4 +#define NDEF_MIFARE_CLASSIC_TAG 101 + +#define STATUS_CODE_TARGET_LOST 146 // this error code comes from the service + +static uint32_t sCheckNdefCurrentSize = 0; +static tNFA_STATUS sCheckNdefStatus = 0; //whether tag already contains a NDEF message +static bool sCheckNdefCapable = false; //whether tag has NDEF capability +static tNFA_HANDLE sNdefTypeHandlerHandle = NFA_HANDLE_INVALID; +static tNFA_INTF_TYPE sCurrentRfInterface = NFA_INTERFACE_ISO_DEP; +static uint8_t* sTransceiveData = NULL; +static uint32_t sTransceiveDataLen = 0; +static bool sWaitingForTransceive = false; +static bool sNeedToSwitchRf = false; +static Mutex sRfInterfaceMutex; +static uint32_t sReadDataLen = 0; +static uint8_t* sReadData = NULL; +static bool sIsReadingNdefMessage = false; +static SyncEvent sReadEvent; +static sem_t sWriteSem; +static sem_t sFormatSem; +static SyncEvent sTransceiveEvent; +static SyncEvent sReconnectEvent; +static sem_t sCheckNdefSem; +static sem_t sPresenceCheckSem; +static sem_t sMakeReadonlySem; +static IntervalTimer sSwitchBackTimer; // timer used to tell us to switch back to ISO_DEP frame interface +static jboolean sWriteOk = JNI_FALSE; +static jboolean sWriteWaitingForComplete = JNI_FALSE; +static bool sFormatOk = false; +static jboolean sConnectOk = JNI_FALSE; +static jboolean sConnectWaitingForComplete = JNI_FALSE; +static bool sGotDeactivate = false; +static uint32_t sCheckNdefMaxSize = 0; +static bool sCheckNdefCardReadOnly = false; +static jboolean sCheckNdefWaitingForComplete = JNI_FALSE; +static int sCountTagAway = 0; //count the consecutive number of presence-check failures +static tNFA_STATUS sMakeReadonlyStatus = NFA_STATUS_FAILED; +static jboolean sMakeReadonlyWaitingForComplete = JNI_FALSE; + +static int reSelect (tNFA_INTF_TYPE rfInterface); +static bool switchRfInterface(tNFA_INTF_TYPE rfInterface); + + +/******************************************************************************* +** +** Function: nativeNfcTag_abortWaits +** +** Description: Unblock all thread synchronization objects. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_abortWaits () +{ + ALOGD ("%s", __FUNCTION__); + { + SyncEventGuard g (sReadEvent); + sReadEvent.notifyOne (); + } + sem_post (&sWriteSem); + sem_post (&sFormatSem); + { + SyncEventGuard g (sTransceiveEvent); + sTransceiveEvent.notifyOne (); + } + { + SyncEventGuard g (sReconnectEvent); + sReconnectEvent.notifyOne (); + } + + sem_post (&sCheckNdefSem); + sem_post (&sPresenceCheckSem); + sem_post (&sMakeReadonlySem); +} + + +/******************************************************************************* +** +** Function: switchBackTimerProc +** +** Description: Callback function for interval timer. +** +** Returns: None +** +*******************************************************************************/ +static void switchBackTimerProc (union sigval) +{ + ALOGD ("%s", __FUNCTION__); + switchRfInterface(NFA_INTERFACE_ISO_DEP); +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doReadCompleted +** +** Description: Receive the completion status of read operation. Called by +** NFA_READ_CPLT_EVT. +** status: Status of operation. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_doReadCompleted (tNFA_STATUS status) +{ + ALOGD ("%s: status=0x%X; is reading=%u", __FUNCTION__, status, sIsReadingNdefMessage); + + if (sIsReadingNdefMessage == false) + return; //not reading NDEF message right now, so just return + + if (status != NFA_STATUS_OK) + { + sReadDataLen = 0; + if (sReadData) + free (sReadData); + sReadData = NULL; + } + SyncEventGuard g (sReadEvent); + sReadEvent.notifyOne (); +} + + +/******************************************************************************* +** +** Function: ndefHandlerCallback +** +** Description: Receive NDEF-message related events from stack. +** event: Event code. +** p_data: Event data. +** +** Returns: None +** +*******************************************************************************/ +static void ndefHandlerCallback (tNFA_NDEF_EVT event, tNFA_NDEF_EVT_DATA *eventData) +{ + ALOGD ("%s: event=%u, eventData=%p", __FUNCTION__, event, eventData); + + switch (event) + { + case NFA_NDEF_REGISTER_EVT: + { + tNFA_NDEF_REGISTER& ndef_reg = eventData->ndef_reg; + ALOGD ("%s: NFA_NDEF_REGISTER_EVT; status=0x%X; h=0x%X", __FUNCTION__, ndef_reg.status, ndef_reg.ndef_type_handle); + sNdefTypeHandlerHandle = ndef_reg.ndef_type_handle; + } + break; + + case NFA_NDEF_DATA_EVT: + { + ALOGD ("%s: NFA_NDEF_DATA_EVT; data_len = %lu", __FUNCTION__, eventData->ndef_data.len); + sReadDataLen = eventData->ndef_data.len; + sReadData = (uint8_t*) malloc (sReadDataLen); + memcpy (sReadData, eventData->ndef_data.p_data, eventData->ndef_data.len); + } + break; + + default: + ALOGE ("%s: Unknown event %u ????", __FUNCTION__, event); + break; + } +} + + +/******************************************************************************* +** +** 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 o) +{ + 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 emtpy buffer", __FUNCTION__); + static uint8_t* empty = (uint8_t*) ""; + 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; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doWriteStatus +** +** Description: Receive the completion status of write operation. Called +** by NFA_WRITE_CPLT_EVT. +** isWriteOk: Status of operation. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_doWriteStatus (jboolean isWriteOk) +{ + if (sWriteWaitingForComplete != JNI_FALSE) + { + sWriteWaitingForComplete = JNI_FALSE; + sWriteOk = isWriteOk; + sem_post (&sWriteSem); + } +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_formatStatus +** +** Description: Receive the completion status of format operation. Called +** by NFA_FORMAT_CPLT_EVT. +** isOk: Status of operation. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_formatStatus (bool isOk) +{ + sFormatOk = isOk; + sem_post (&sFormatSem); +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doWrite +** +** Description: Write a NDEF message to the tag. +** e: JVM environment. +** o: Java object. +** buf: Contains a NDEF message. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeNfcTag_doWrite (JNIEnv *e, jobject o, jbyteArray buf) +{ + jboolean result = JNI_FALSE; + tNFA_STATUS status = 0; + UINT32 len = 0; + UINT8* p_data = NULL; + const int maxBufferSize = 1024; + UINT8 buffer[maxBufferSize] = { 0 }; + UINT32 curDataSize = 0; + + len = (UINT32) e->GetArrayLength (buf); + p_data = (UINT8*) e->GetByteArrayElements (buf, NULL); + + ALOGD ("%s: enter; len = %lu", __FUNCTION__, len); + + /* Create the write semaphore */ + if (sem_init (&sWriteSem, 0, 0) == -1) + { + ALOGE ("%s: semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno); + return JNI_FALSE; + } + + sWriteWaitingForComplete = JNI_TRUE; + if (sCheckNdefStatus == NFA_STATUS_FAILED) + { + //if tag does not contain a NDEF message + //and tag is capable of storing NDEF message + if (sCheckNdefCapable) + { + ALOGD ("%s: try format", __FUNCTION__); + sem_init (&sFormatSem, 0, 0); + sFormatOk = false; + status = NFA_RwFormatTag (); + sem_wait (&sFormatSem); + sem_destroy (&sFormatSem); + if (sFormatOk == false) //if format operation failed + goto TheEnd; + } + ALOGD ("%s: try write", __FUNCTION__); + status = NFA_RwWriteNDef (p_data, len); + } + else if (len == 0) + { + //if (NXP TagWriter wants to erase tag) then create and write an empty ndef message + NDEF_MsgInit (buffer, maxBufferSize, &curDataSize); + status = NDEF_MsgAddRec (buffer, maxBufferSize, &curDataSize, NDEF_TNF_EMPTY, NULL, 0, NULL, 0, NULL, 0); + ALOGD ("%s: create empty ndef msg; status=%u; size=%lu", __FUNCTION__, status, curDataSize); + status = NFA_RwWriteNDef (buffer, curDataSize); + } + else + { + ALOGD ("%s: NFA_RwWriteNDef", __FUNCTION__); + status = NFA_RwWriteNDef (p_data, len); + } + + if (status != NFA_STATUS_OK) + { + ALOGE ("%s: write/format error=%d", __FUNCTION__, status); + goto TheEnd; + } + + /* Wait for write completion status */ + sWriteOk = false; + if (sem_wait (&sWriteSem)) + { + ALOGE ("%s: wait semaphore (errno=0x%08x)", __FUNCTION__, errno); + goto TheEnd; + } + + result = sWriteOk; + +TheEnd: + /* Destroy semaphore */ + if (sem_destroy (&sWriteSem)) + { + ALOGE ("%s: failed destroy semaphore (errno=0x%08x)", __FUNCTION__, errno); + } + sWriteWaitingForComplete = JNI_FALSE; + ALOGD ("%s: exit; result=%d", __FUNCTION__, result); + return result; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doConnectStatus +** +** Description: Receive the completion status of connect operation. +** isConnectOk: Status of the operation. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_doConnectStatus (jboolean isConnectOk) +{ + if (sConnectWaitingForComplete != JNI_FALSE) + { + sConnectWaitingForComplete = JNI_FALSE; + sConnectOk = isConnectOk; + SyncEventGuard g (sReconnectEvent); + sReconnectEvent.notifyOne (); + } +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doDeactivateStatus +** +** Description: Receive the completion status of deactivate operation. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_doDeactivateStatus (int status) +{ + sGotDeactivate = (status == 0); + + SyncEventGuard g (sReconnectEvent); + sReconnectEvent.notifyOne (); +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doConnect +** +** Description: Connect to the tag in RF field. +** e: JVM environment. +** o: Java object. +** targetHandle: Handle of the tag. +** +** Returns: Must return NXP status code, which NFC service expects. +** +*******************************************************************************/ +static jint nativeNfcTag_doConnect (JNIEnv *e, jobject o, jint targetHandle) +{ + ALOGD ("%s: targetHandle = %d", __FUNCTION__, targetHandle); + int i = targetHandle; + struct nfc_jni_native_data *nat = getNative (0, 0); + NfcTag& natTag = NfcTag::getInstance (); + int retCode = NFCSTATUS_SUCCESS; + + sNeedToSwitchRf = false; + if (i >= NfcTag::MAX_NUM_TECHNOLOGY) + { + ALOGE ("%s: Handle not found", __FUNCTION__); + retCode = NFCSTATUS_FAILED; + goto TheEnd; + } + + if (natTag.getActivationState() != NfcTag::Active) + { + ALOGE ("%s: tag already deactivated", __FUNCTION__); + retCode = NFCSTATUS_FAILED; + goto TheEnd; + } + + if (natTag.mTechLibNfcTypes[i] != NFC_PROTOCOL_ISO_DEP) + { + ALOGD ("%s() Nfc type = %d, do nothing for non ISO_DEP", __FUNCTION__, natTag.mTechLibNfcTypes[i]); + retCode = NFCSTATUS_SUCCESS; + goto TheEnd; + } + + if (natTag.mTechList[i] == TARGET_TYPE_ISO14443_3A || natTag.mTechList[i] == TARGET_TYPE_ISO14443_3B) + { + ALOGD ("%s: switching to tech: %d need to switch rf intf to frame", __FUNCTION__, natTag.mTechList[i]); + // connecting to NfcA or NfcB don't actually switch until/unless we get a transceive + sNeedToSwitchRf = true; + } + else + { + // connecting back to IsoDep or NDEF + return (switchRfInterface (NFA_INTERFACE_ISO_DEP) ? NFCSTATUS_SUCCESS : NFCSTATUS_FAILED); + } + +TheEnd: + ALOGD ("%s: exit 0x%X", __FUNCTION__, retCode); + return retCode; +} + +/******************************************************************************* +** +** 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) +{ + ALOGD ("%s: enter; rf intf = %d", __FUNCTION__, rfInterface); + 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 (NfcTag::getInstance ().getActivationState () != NfcTag::Sleep) + { + ALOGD ("%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) + { + ALOGD("%s: tag is not active", __FUNCTION__); + rVal = STATUS_CODE_TARGET_LOST; + break; + } + rVal = (sConnectOk) ? 0 : 1; + } while (0); + + sConnectWaitingForComplete = JNI_FALSE; + gIsTagDeactivating = false; + gIsSelectingRfInterface = false; + ALOGD ("%s: exit; status=%d", __FUNCTION__, rVal); + return rVal; +} + +/******************************************************************************* +** +** Function: switchRfInterface +** +** Description: Switch controller's RF interface to frame, ISO-DEP, or NFC-DEP. +** rfInterface: Type of RF interface. +** +** Returns: True if ok. +** +*******************************************************************************/ +static bool switchRfInterface (tNFA_INTF_TYPE rfInterface) +{ + ALOGD ("%s: rf intf = %d", __FUNCTION__, rfInterface); + NfcTag& natTag = NfcTag::getInstance (); + + if (natTag.mTechLibNfcTypes[0] != NFC_PROTOCOL_ISO_DEP) + { + ALOGD ("%s: protocol: %d not ISO_DEP, do nothing", __FUNCTION__, natTag.mTechLibNfcTypes[0]); + return true; + } + + sRfInterfaceMutex.lock (); + ALOGD ("%s: new rf intf = %d, cur rf intf = %d", __FUNCTION__, rfInterface, sCurrentRfInterface); + + bool rVal = true; + if (rfInterface != sCurrentRfInterface) + { + if (rVal = (0 == reSelect(rfInterface))) + { + sCurrentRfInterface = rfInterface; + } + } + + sRfInterfaceMutex.unlock (); + return rVal; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doReconnect +** +** Description: Re-connect to the tag in RF field. +** e: JVM environment. +** o: Java object. +** +** Returns: Status code. +** +*******************************************************************************/ +static jint nativeNfcTag_doReconnect (JNIEnv *e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + int retCode = NFCSTATUS_SUCCESS; + NfcTag& natTag = NfcTag::getInstance (); + + if (natTag.getActivationState() != NfcTag::Active) + { + ALOGE ("%s: tag already deactivated", __FUNCTION__); + retCode = NFCSTATUS_FAILED; + goto TheEnd; + } + + // this is only supported for type 2 or 4 (ISO_DEP) tags + if (natTag.mTechLibNfcTypes[0] == NFA_PROTOCOL_ISO_DEP) + retCode = reSelect(NFA_INTERFACE_ISO_DEP); + else if (natTag.mTechLibNfcTypes[0] == NFA_PROTOCOL_T2T) + retCode = reSelect(NFA_INTERFACE_FRAME); + +TheEnd: + ALOGD ("%s: exit 0x%X", __FUNCTION__, retCode); + return retCode; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doHandleReconnect +** +** Description: Re-connect to the tag in RF field. +** e: JVM environment. +** o: Java object. +** targetHandle: Handle of the tag. +** +** Returns: Status code. +** +*******************************************************************************/ +static jint nativeNfcTag_doHandleReconnect (JNIEnv *e, jobject o, jint targetHandle) +{ + ALOGD ("%s: targetHandle = %d", __FUNCTION__, targetHandle); + return nativeNfcTag_doConnect (e, o, targetHandle); +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doDisconnect +** +** Description: Deactivate the RF field. +** e: JVM environment. +** o: Java object. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeNfcTag_doDisconnect (JNIEnv *e, jobject o) +{ + ALOGD ("%s: enter", __FUNCTION__); + struct nfc_jni_native_data *nat = getNative (0, 0); + tNFA_STATUS nfaStat = NFA_STATUS_OK; + + gGeneralTransceiveTimeout = DEFAULT_GENERAL_TRANS_TIMEOUT; + + if (NfcTag::getInstance ().getActivationState () != NfcTag::Active) + { + ALOGE ("%s: tag already deactivated", __FUNCTION__); + goto TheEnd; + } + + nfaStat = NFA_Deactivate (FALSE); + if (nfaStat != NFA_STATUS_OK) + ALOGE ("%s: deactivate failed; error=0x%X", __FUNCTION__, nfaStat); + +TheEnd: + ALOGD ("%s: exit", __FUNCTION__); + return (nfaStat == NFA_STATUS_OK) ? JNI_TRUE : JNI_FALSE; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doTransceiveStatus +** +** Description: Receive the completion status of transceive operation. +** buf: Contains tag's response. +** bufLen: Length of buffer. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_doTransceiveStatus (uint8_t* buf, uint32_t bufLen) +{ + ALOGD ("%s: data len=%d, waiting for transceive: %d", __FUNCTION__, bufLen, sWaitingForTransceive); + if (!sWaitingForTransceive) + return; + + sTransceiveDataLen = 0; + if (bufLen) + { + if (NULL == (sTransceiveData = (uint8_t *) malloc (bufLen))) + { + ALOGD ("%s: memory allocation error", __FUNCTION__); + } + else + { + memcpy (sTransceiveData, buf, sTransceiveDataLen = bufLen); + } + } + + { + SyncEventGuard g (sTransceiveEvent); + sTransceiveEvent.notifyOne (); + } +} + + +/******************************************************************************* +** +** 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 o, jbyteArray data, jboolean raw, jintArray statusTargetLost) +{ + ALOGD ("%s: enter; raw=%u; timeout = %d", __FUNCTION__, raw, gGeneralTransceiveTimeout); + bool fNeedToSwitchBack = false; + nfc_jni_native_data *nat = getNative (0, 0); + bool waitOk = false; + bool isNack = false; + uint8_t *buf = NULL; + uint32_t bufLen = 0; + 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 + buf = (uint8_t *) e->GetByteArrayElements (data, NULL); + bufLen = (uint32_t) e->GetArrayLength (data); + + if (statusTargetLost) + { + targetLost = e->GetIntArrayElements (statusTargetLost, 0); + if (targetLost) + *targetLost = 0; //success, tag is still present + } + + sSwitchBackTimer.kill (); + jbyteArray result = NULL; + do + { + if (sNeedToSwitchRf) + { + // for ISO_DEP tags connected to NfcA or NfcB we need to be in FRAME interface + if (!switchRfInterface (NFA_INTERFACE_FRAME)) //NFA_INTERFACE_ISO_DEP + { + break; + } + fNeedToSwitchBack = true; + } + + sWaitingForTransceive = true; + sTransceiveDataLen = 0; + { + SyncEventGuard g (sTransceiveEvent); + tNFA_STATUS status = NFA_SendRawFrame (buf, bufLen); + if (status != NFA_STATUS_OK) + { + ALOGE ("%s: fail send; error=%d", __FUNCTION__, status); + break; + } + waitOk = sTransceiveEvent.wait (gGeneralTransceiveTimeout); + } + + if (waitOk == false) //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__, sTransceiveDataLen); + + if ((natTag.getProtocol () == NFA_PROTOCOL_T2T) && + natTag.isT2tNackResponse (sTransceiveData, sTransceiveDataLen)) + { + isNack = true; + } + + if (sTransceiveDataLen) + { + if (!isNack) { + // marshall data to java for return + result = e->NewByteArray (sTransceiveDataLen); + if (result != NULL) + { + e->SetByteArrayRegion (result, 0, sTransceiveDataLen, (jbyte *) sTransceiveData); + } + else + ALOGE ("%s: Failed to allocate java byte array", __FUNCTION__); + } // else a nack is treated as a transceive failure to the upper layers + + free (sTransceiveData); + sTransceiveData = NULL; + sTransceiveDataLen = 0; + } + } while (0); + + sWaitingForTransceive = false; + e->ReleaseByteArrayElements (data, (jbyte *) buf, JNI_ABORT); + if (targetLost) + e->ReleaseIntArrayElements (statusTargetLost, targetLost, 0); + + if (fNeedToSwitchBack) + { + // this timer proc will switch us back to ISO_DEP frame interface + sSwitchBackTimer.set (1500, switchBackTimerProc); + } + + ALOGD ("%s: exit", __FUNCTION__); + return result; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doGetNdefType +** +** Description: Retrieve the type of tag. +** e: JVM environment. +** o: Java object. +** libnfcType: Type of tag represented by JNI. +** javaType: Not used. +** +** Returns: Type of tag represented by NFC Service. +** +*******************************************************************************/ +static jint nativeNfcTag_doGetNdefType (JNIEnv *e, jobject o, jint libnfcType, jint javaType) +{ + ALOGD ("%s: enter; libnfc type=%d; java type=%d", __FUNCTION__, libnfcType, javaType); + jint ndefType = NDEF_UNKNOWN_TYPE; + + // For NFA, libnfcType is mapped to the protocol value received + // in the NFA_ACTIVATED_EVT and NFA_DISC_RESULT_EVT event. + switch (libnfcType) { + case NFA_PROTOCOL_T1T: + ndefType = NDEF_TYPE1_TAG; + break; + case NFA_PROTOCOL_T2T: + ndefType = NDEF_TYPE2_TAG;; + break; + case NFA_PROTOCOL_T3T: + ndefType = NDEF_TYPE3_TAG; + break; + case NFA_PROTOCOL_ISO_DEP: + ndefType = NDEF_TYPE4_TAG; + break; + case NFA_PROTOCOL_ISO15693: + ndefType = NDEF_UNKNOWN_TYPE; + break; + case NFA_PROTOCOL_INVALID: + ndefType = NDEF_UNKNOWN_TYPE; + break; + default: + ndefType = NDEF_UNKNOWN_TYPE; + break; + } + ALOGD ("%s: exit; ndef type=%d", __FUNCTION__, ndefType); + return ndefType; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doCheckNdefResult +** +** Description: Receive the result of checking whether the tag contains a NDEF +** message. Called by the NFA_NDEF_DETECT_EVT. +** status: Status of the operation. +** maxSize: Maximum size of NDEF message. +** currentSize: Current size of NDEF message. +** flags: Indicate various states. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_doCheckNdefResult (tNFA_STATUS status, uint32_t maxSize, uint32_t currentSize, uint8_t flags) +{ + //this function's flags parameter is defined using the following macros + //in nfc/include/rw_api.h; + //#define RW_NDEF_FL_READ_ONLY 0x01 /* Tag is read only */ + //#define RW_NDEF_FL_FORMATED 0x02 /* Tag formated for NDEF */ + //#define RW_NDEF_FL_SUPPORTED 0x04 /* NDEF supported by the tag */ + //#define RW_NDEF_FL_UNKNOWN 0x08 /* Unable to find if tag is ndef capable/formated/read only */ + //#define RW_NDEF_FL_FORMATABLE 0x10 /* Tag supports format operation */ + + if (status == NFC_STATUS_BUSY) + { + ALOGE ("%s: stack is busy", __FUNCTION__); + return; + } + + if (!sCheckNdefWaitingForComplete) + { + ALOGE ("%s: not waiting", __FUNCTION__); + return; + } + + if (flags & RW_NDEF_FL_READ_ONLY) + ALOGD ("%s: flag read-only", __FUNCTION__); + if (flags & RW_NDEF_FL_FORMATED) + ALOGD ("%s: flag formatted for ndef", __FUNCTION__); + if (flags & RW_NDEF_FL_SUPPORTED) + ALOGD ("%s: flag ndef supported", __FUNCTION__); + if (flags & RW_NDEF_FL_UNKNOWN) + ALOGD ("%s: flag all unknown", __FUNCTION__); + if (flags & RW_NDEF_FL_FORMATABLE) + ALOGD ("%s: flag formattable", __FUNCTION__); + + sCheckNdefWaitingForComplete = JNI_FALSE; + sCheckNdefStatus = status; + sCheckNdefCapable = false; //assume tag is NOT ndef capable + if (sCheckNdefStatus == NFA_STATUS_OK) + { + //NDEF content is on the tag + sCheckNdefMaxSize = maxSize; + sCheckNdefCurrentSize = currentSize; + sCheckNdefCardReadOnly = flags & RW_NDEF_FL_READ_ONLY; + sCheckNdefCapable = true; + } + else if (sCheckNdefStatus == NFA_STATUS_FAILED) + { + //no NDEF content on the tag + sCheckNdefMaxSize = 0; + sCheckNdefCurrentSize = 0; + sCheckNdefCardReadOnly = flags & RW_NDEF_FL_READ_ONLY; + if ((flags & RW_NDEF_FL_UNKNOWN) == 0) //if stack understands the tag + { + if (flags & RW_NDEF_FL_SUPPORTED) //if tag is ndef capable + sCheckNdefCapable = true; + } + } + else + { + ALOGE ("%s: unknown status=0x%X", __FUNCTION__, status); + sCheckNdefMaxSize = 0; + sCheckNdefCurrentSize = 0; + sCheckNdefCardReadOnly = false; + } + sem_post (&sCheckNdefSem); +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doCheckNdef +** +** Description: Does the tag contain a NDEF message? +** e: JVM environment. +** o: Java object. +** ndefInfo: NDEF info. +** +** Returns: Status code; 0 is success. +** +*******************************************************************************/ +static jint nativeNfcTag_doCheckNdef (JNIEnv *e, jobject o, jintArray ndefInfo) +{ + tNFA_STATUS status = NFA_STATUS_FAILED; + jint* ndef = NULL; + + ALOGD ("%s: enter", __FUNCTION__); + + /* Create the write semaphore */ + if (sem_init (&sCheckNdefSem, 0, 0) == -1) + { + ALOGE ("%s: Check NDEF semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno); + return JNI_FALSE; + } + + if (NfcTag::getInstance ().getActivationState () != NfcTag::Active) + { + ALOGE ("%s: tag already deactivated", __FUNCTION__); + goto TheEnd; + } + + ALOGD ("%s: try NFA_RwDetectNDef", __FUNCTION__); + sCheckNdefWaitingForComplete = JNI_TRUE; + status = NFA_RwDetectNDef (); + + if (status != NFA_STATUS_OK) + { + ALOGE ("%s: NFA_RwDetectNDef failed, status = 0x%X", __FUNCTION__, status); + goto TheEnd; + } + + /* Wait for check NDEF completion status */ + if (sem_wait (&sCheckNdefSem)) + { + ALOGE ("%s: Failed to wait for check NDEF semaphore (errno=0x%08x)", __FUNCTION__, errno); + goto TheEnd; + } + + if (sCheckNdefStatus == NFA_STATUS_OK) + { + //stack found a NDEF message on the tag + ndef = e->GetIntArrayElements (ndefInfo, 0); + if (NfcTag::getInstance ().getProtocol () == NFA_PROTOCOL_T1T) + ndef[0] = NfcTag::getInstance ().getT1tMaxMessageSize (); + else + ndef[0] = sCheckNdefMaxSize; + if (sCheckNdefCardReadOnly) + ndef[1] = NDEF_MODE_READ_ONLY; + else + ndef[1] = NDEF_MODE_READ_WRITE; + e->ReleaseIntArrayElements (ndefInfo, ndef, 0); + status = NFA_STATUS_OK; + } + else if (sCheckNdefStatus == NFA_STATUS_FAILED) + { + //stack did not find a NDEF message on the tag; + ndef = e->GetIntArrayElements (ndefInfo, 0); + if (NfcTag::getInstance ().getProtocol () == NFA_PROTOCOL_T1T) + ndef[0] = NfcTag::getInstance ().getT1tMaxMessageSize (); + else + ndef[0] = sCheckNdefMaxSize; + if (sCheckNdefCardReadOnly) + ndef[1] = NDEF_MODE_READ_ONLY; + else + ndef[1] = NDEF_MODE_READ_WRITE; + e->ReleaseIntArrayElements (ndefInfo, ndef, 0); + status = NFA_STATUS_FAILED; + } + else if (sCheckNdefStatus == NFA_STATUS_TIMEOUT) + { + pn544InteropStopPolling (); + status = sCheckNdefStatus; + } + else + { + ALOGD ("%s: unknown status 0x%X", __FUNCTION__, sCheckNdefStatus); + status = sCheckNdefStatus; + } + +TheEnd: + /* Destroy semaphore */ + if (sem_destroy (&sCheckNdefSem)) + { + ALOGE ("%s: Failed to destroy check NDEF semaphore (errno=0x%08x)", __FUNCTION__, errno); + } + sCheckNdefWaitingForComplete = JNI_FALSE; + ALOGD ("%s: exit; status=0x%X", __FUNCTION__, status); + return status; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_resetPresenceCheck +** +** Description: Reset variables related to presence-check. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_resetPresenceCheck () +{ + sCountTagAway = 0; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doPresenceCheckResult +** +** Description: Receive the result of presence-check. +** status: Result of presence-check. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_doPresenceCheckResult (tNFA_STATUS status) +{ + if (status == NFA_STATUS_OK) + sCountTagAway = 0; + else + sCountTagAway++; + if (sCountTagAway > 0) + ALOGD ("%s: sCountTagAway=%d", __FUNCTION__, sCountTagAway); + sem_post (&sPresenceCheckSem); +} + + +/******************************************************************************* +** +** 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 *e, jobject o) +{ + ALOGD ("%s", __FUNCTION__); + tNFA_STATUS status = NFA_STATUS_OK; + jboolean isPresent = JNI_FALSE; + + if (nfcManager_isNfcActive() == false) + { + ALOGD ("%s: NFC is no longer active.", __FUNCTION__); + return JNI_FALSE; + } + + if (NfcTag::getInstance ().getActivationState () != NfcTag::Active) + { + ALOGD ("%s: tag already deactivated", __FUNCTION__); + return JNI_FALSE; + } + + if (sem_init (&sPresenceCheckSem, 0, 0) == -1) + { + ALOGE ("%s: semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno); + return JNI_FALSE; + } + + status = NFA_RwPresenceCheck (); + if (status == NFA_STATUS_OK) + { + if (sem_wait (&sPresenceCheckSem)) + { + ALOGE ("%s: failed to wait (errno=0x%08x)", __FUNCTION__, errno); + } + else + { + isPresent = (sCountTagAway > 3) ? JNI_FALSE : JNI_TRUE; + } + } + + if (sem_destroy (&sPresenceCheckSem)) + { + ALOGE ("Failed to destroy check NDEF semaphore (errno=0x%08x)", errno); + } + + if (isPresent == JNI_FALSE) + ALOGD ("%s: tag absent ????", __FUNCTION__); + return isPresent; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doIsNdefFormatable +** +** Description: Can tag be formatted to store NDEF message? +** e: JVM environment. +** o: Java object. +** libNfcType: Type of tag. +** uidBytes: Tag's unique ID. +** pollBytes: Data from activation. +** actBytes: Data from activation. +** +** Returns: True if formattable. +** +*******************************************************************************/ +static jboolean nativeNfcTag_doIsNdefFormatable (JNIEnv *e, + jobject o, jint libNfcType, jbyteArray uidBytes, jbyteArray pollBytes, + jbyteArray actBytes) +{ + jboolean isFormattable = JNI_FALSE; + + switch (NfcTag::getInstance().getProtocol()) + { + case NFA_PROTOCOL_T1T: + case NFA_PROTOCOL_ISO15693: + isFormattable = JNI_TRUE; + break; + + case NFA_PROTOCOL_T2T: + isFormattable = NfcTag::getInstance().isMifareUltralight() ? JNI_TRUE : JNI_FALSE; + } + ALOGD("%s: is formattable=%u", __FUNCTION__, isFormattable); + return isFormattable; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doIsIsoDepNdefFormatable +** +** Description: Is ISO-DEP tag formattable? +** e: JVM environment. +** o: Java object. +** pollBytes: Data from activation. +** actBytes: Data from activation. +** +** Returns: True if formattable. +** +*******************************************************************************/ +static jboolean nativeNfcTag_doIsIsoDepNdefFormatable (JNIEnv *e, jobject o, jbyteArray pollBytes, jbyteArray actBytes) +{ + uint8_t uidFake[] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }; + ALOGD ("%s", __FUNCTION__); + jbyteArray uidArray = e->NewByteArray (8); + e->SetByteArrayRegion (uidArray, 0, 8, (jbyte*) uidFake); + return nativeNfcTag_doIsNdefFormatable (e, o, 0, uidArray, pollBytes, actBytes); +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doNdefFormat +** +** Description: Format a tag so it can store NDEF message. +** e: JVM environment. +** o: Java object. +** key: Not used. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeNfcTag_doNdefFormat (JNIEnv *e, jobject o, jbyteArray key) +{ + ALOGD ("%s: enter", __FUNCTION__); + tNFA_STATUS status = NFA_STATUS_OK; + + sem_init (&sFormatSem, 0, 0); + sFormatOk = false; + status = NFA_RwFormatTag (); + if (status == NFA_STATUS_OK) + { + ALOGD ("%s: wait for completion", __FUNCTION__); + sem_wait (&sFormatSem); + status = sFormatOk ? NFA_STATUS_OK : NFA_STATUS_FAILED; + } + else + ALOGE ("%s: error status=%u", __FUNCTION__, status); + sem_destroy (&sFormatSem); + + ALOGD ("%s: exit", __FUNCTION__); + return (status == NFA_STATUS_OK) ? JNI_TRUE : JNI_FALSE; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doMakeReadonlyResult +** +** Description: Receive the result of making a tag read-only. Called by the +** NFA_SET_TAG_RO_EVT. +** status: Status of the operation. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_doMakeReadonlyResult (tNFA_STATUS status) +{ + if (sMakeReadonlyWaitingForComplete != JNI_FALSE) + { + sMakeReadonlyWaitingForComplete = JNI_FALSE; + sMakeReadonlyStatus = status; + + sem_post (&sMakeReadonlySem); + } +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_doMakeReadonly +** +** Description: Make the tag read-only. +** e: JVM environment. +** o: Java object. +** key: Key to access the tag. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeNfcTag_doMakeReadonly (JNIEnv *e, jobject o, jbyteArray key) +{ + jboolean result = JNI_FALSE; + tNFA_STATUS status; + + ALOGD ("%s", __FUNCTION__); + + /* Create the make_readonly semaphore */ + if (sem_init (&sMakeReadonlySem, 0, 0) == -1) + { + ALOGE ("%s: Make readonly semaphore creation failed (errno=0x%08x)", __FUNCTION__, errno); + return JNI_FALSE; + } + + sMakeReadonlyWaitingForComplete = JNI_TRUE; + + // Hard-lock the tag (cannot be reverted) + status = NFA_RwSetTagReadOnly(TRUE); + + if (status != NFA_STATUS_OK) + { + ALOGE ("%s: NFA_RwSetTagReadOnly failed, status = %d", __FUNCTION__, status); + goto TheEnd; + } + + /* Wait for check NDEF completion status */ + if (sem_wait (&sMakeReadonlySem)) + { + ALOGE ("%s: Failed to wait for make_readonly semaphore (errno=0x%08x)", __FUNCTION__, errno); + goto TheEnd; + } + + if (sMakeReadonlyStatus == NFA_STATUS_OK) + { + result = JNI_TRUE; + } + +TheEnd: + /* Destroy semaphore */ + if (sem_destroy (&sMakeReadonlySem)) + { + ALOGE ("%s: Failed to destroy read_only semaphore (errno=0x%08x)", __FUNCTION__, errno); + } + sMakeReadonlyWaitingForComplete = JNI_FALSE; + return result; +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_registerNdefTypeHandler +** +** Description: Register a callback to receive NDEF message from the tag +** from the NFA_NDEF_DATA_EVT. +** +** Returns: None +** +*******************************************************************************/ +//register a callback to receive NDEF message from the tag +//from the NFA_NDEF_DATA_EVT; +void nativeNfcTag_registerNdefTypeHandler () +{ + ALOGD ("%s", __FUNCTION__); + sNdefTypeHandlerHandle = NFA_HANDLE_INVALID; + NFA_RegisterNDefTypeHandler (TRUE, NFA_TNF_DEFAULT, (UINT8 *) "", 0, ndefHandlerCallback); +} + + +/******************************************************************************* +** +** Function: nativeNfcTag_deregisterNdefTypeHandler +** +** Description: No longer need to receive NDEF message from the tag. +** +** Returns: None +** +*******************************************************************************/ +void nativeNfcTag_deregisterNdefTypeHandler () +{ + ALOGD ("%s", __FUNCTION__); + NFA_DeregisterNDefTypeHandler (sNdefTypeHandlerHandle); + sNdefTypeHandlerHandle = NFA_HANDLE_INVALID; +} + + +/***************************************************************************** +** +** JNI functions for Android 4.0.3 +** +*****************************************************************************/ +static JNINativeMethod gMethods[] = +{ + {"doConnect", "(I)I", (void *)nativeNfcTag_doConnect}, + {"doDisconnect", "()Z", (void *)nativeNfcTag_doDisconnect}, + {"doReconnect", "()I", (void *)nativeNfcTag_doReconnect}, + {"doHandleReconnect", "(I)I", (void *)nativeNfcTag_doHandleReconnect}, + {"doTransceive", "([BZ[I)[B", (void *)nativeNfcTag_doTransceive}, + {"doGetNdefType", "(II)I", (void *)nativeNfcTag_doGetNdefType}, + {"doCheckNdef", "([I)I", (void *)nativeNfcTag_doCheckNdef}, + {"doRead", "()[B", (void *)nativeNfcTag_doRead}, + {"doWrite", "([B)Z", (void *)nativeNfcTag_doWrite}, + {"doPresenceCheck", "()Z", (void *)nativeNfcTag_doPresenceCheck}, + {"doIsIsoDepNdefFormatable", "([B[B)Z", (void *)nativeNfcTag_doIsIsoDepNdefFormatable}, + {"doNdefFormat", "([B)Z", (void *)nativeNfcTag_doNdefFormat}, + {"doMakeReadonly", "([B)Z", (void *)nativeNfcTag_doMakeReadonly}, +}; + + +/******************************************************************************* +** +** Function: register_com_android_nfc_NativeNfcTag +** +** Description: Regisgter JNI functions with Java Virtual Machine. +** e: Environment of JVM. +** +** Returns: Status of registration. +** +*******************************************************************************/ +int register_com_android_nfc_NativeNfcTag (JNIEnv *e) +{ + ALOGD ("%s", __FUNCTION__); + return jniRegisterNativeMethods (e, gNativeNfcTagClassName, gMethods, NELEM (gMethods)); +} + + +} /* namespace android */ diff --git a/nci/jni/NativeP2pDevice.cpp b/nci/jni/NativeP2pDevice.cpp new file mode 100644 index 0000000..57f9dad --- /dev/null +++ b/nci/jni/NativeP2pDevice.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "OverrideLog.h" +#include "NfcJniUtil.h" +#include "JavaClassConstants.h" + + +namespace android +{ + + +static jboolean nativeP2pDeviceDoConnect (JNIEnv* e, jobject o) +{ + ALOGD ("%s", __FUNCTION__); + return JNI_TRUE; +} + + +static jboolean nativeP2pDeviceDoDisconnect (JNIEnv* e, jobject o) +{ + ALOGD ("%s", __FUNCTION__); + return JNI_TRUE; +} + + +static jbyteArray nativeP2pDeviceDoTransceive (JNIEnv* e, jobject o, jbyteArray data) +{ + ALOGD ("%s", __FUNCTION__); + return NULL; +} + + +static jbyteArray nativeP2pDeviceDoReceive (JNIEnv* e, jobject o) +{ + ALOGD ("%s", __FUNCTION__); + return NULL; +} + + +static jboolean nativeP2pDeviceDoSend (JNIEnv* e, jobject o, jbyteArray buf) +{ + ALOGD ("%s", __FUNCTION__); + return JNI_TRUE; +} + + +/***************************************************************************** +** +** Description: JNI functions +** +*****************************************************************************/ +static JNINativeMethod gMethods[] = +{ + {"doConnect", "()Z", (void *) nativeP2pDeviceDoConnect}, + {"doDisconnect", "()Z", (void *) nativeP2pDeviceDoDisconnect}, + {"doTransceive", "([B)[B", (void *) nativeP2pDeviceDoTransceive}, + {"doReceive", "()[B", (void *) nativeP2pDeviceDoReceive}, + {"doSend", "([B)Z", (void *) nativeP2pDeviceDoSend}, +}; + + +/******************************************************************************* +** +** Function: register_com_android_nfc_NativeP2pDevice +** +** Description: Regisgter JNI functions with Java Virtual Machine. +** e: Environment of JVM. +** +** Returns: Status of registration. +** +*******************************************************************************/ +int register_com_android_nfc_NativeP2pDevice (JNIEnv* e) +{ + return jniRegisterNativeMethods (e, gNativeP2pDeviceClassName, + gMethods, NELEM(gMethods)); +} + + +} // namepspace android diff --git a/nci/jni/NativeSecureElement.cpp b/nci/jni/NativeSecureElement.cpp new file mode 100755 index 0000000..1a2a73a --- /dev/null +++ b/nci/jni/NativeSecureElement.cpp @@ -0,0 +1,245 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "OverrideLog.h" +#include "SecureElement.h" +#include "JavaClassConstants.h" +#include "PowerSwitch.h" + + +namespace android +{ + + +extern void com_android_nfc_NfcManager_disableDiscovery (JNIEnv* e, jobject o); +extern void com_android_nfc_NfcManager_enableDiscovery (JNIEnv* e, jobject o, jint mode); +extern int gGeneralTransceiveTimeout; + + +/******************************************************************************* +** +** Function: nativeNfcSecureElement_doOpenSecureElementConnection +** +** Description: Connect to the secure element. +** e: JVM environment. +** o: Java object. +** +** Returns: Handle of secure element. 0 is failure. +** +*******************************************************************************/ +static jint nativeNfcSecureElement_doOpenSecureElementConnection (JNIEnv* e, jobject o) +{ + ALOGD("%s: enter", __FUNCTION__); + bool stat = true; + jint secElemHandle = 0; + SecureElement &se = SecureElement::getInstance(); + + if (se.isActivatedInListenMode()) { + ALOGD("Denying SE open due to SE listen mode active"); + goto TheEnd; + } + + if (se.isRfFieldOn()) { + ALOGD("Denying SE open due to SE in active RF field"); + goto TheEnd; + } + //tell the controller to power up to get ready for sec elem operations + PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); + PowerSwitch::getInstance ().setModeOn (PowerSwitch::SE_CONNECTED); + + //if controller is not routing AND there is no pipe connected, + //then turn on the sec elem + if (! se.isBusy()) + stat = se.activate(0); + + if (stat) + { + //establish a pipe to sec elem + stat = se.connectEE(); + if (stat) + secElemHandle = se.mActiveEeHandle; + else + se.deactivate (0); + } + + //if code fails to connect to the secure element, and nothing is active, then + //tell the controller to power down + if ((!stat) && (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::SE_CONNECTED))) + { + PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); + } + +TheEnd: + ALOGD("%s: exit; return handle=0x%X", __FUNCTION__, secElemHandle); + return secElemHandle; +} + + +/******************************************************************************* +** +** Function: nativeNfcSecureElement_doDisconnectSecureElementConnection +** +** Description: Disconnect from the secure element. +** e: JVM environment. +** o: Java object. +** handle: Handle of secure element. +** +** Returns: True if ok. +** +*******************************************************************************/ +static jboolean nativeNfcSecureElement_doDisconnectSecureElementConnection (JNIEnv* e, jobject o, jint handle) +{ + ALOGD("%s: enter; handle=0x%04x", __FUNCTION__, handle); + bool stat = false; + + stat = SecureElement::getInstance().disconnectEE (handle); + + //if controller is not routing AND there is no pipe connected, + //then turn off the sec elem + if (! SecureElement::getInstance().isBusy()) + SecureElement::getInstance().deactivate (handle); + + //if nothing is active after this, then tell the controller to power down + if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::SE_CONNECTED)) + PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); + + ALOGD("%s: exit", __FUNCTION__); + return stat ? JNI_TRUE : JNI_FALSE; +} + + +/******************************************************************************* +** +** Function: nativeNfcSecureElement_doTransceive +** +** Description: Send data to the secure element; retrieve response. +** e: JVM environment. +** o: Java object. +** handle: Secure element's handle. +** data: Data to send. +** +** Returns: Buffer of received data. +** +*******************************************************************************/ +static jbyteArray nativeNfcSecureElement_doTransceive (JNIEnv* e, jobject o, jint handle, jbyteArray data) +{ + UINT8* buf = NULL; + INT32 buflen = 0; + const INT32 recvBufferMaxSize = 1024; + UINT8 recvBuffer [recvBufferMaxSize]; + INT32 recvBufferActualSize = 0; + jbyteArray result = NULL; + + buf = (UINT8*) e->GetByteArrayElements (data, NULL); + buflen = e->GetArrayLength (data); + + ALOGD("%s: enter; handle=0x%X; buf len=%ld", __FUNCTION__, handle, buflen); + SecureElement::getInstance().transceive (buf, buflen, recvBuffer, recvBufferMaxSize, recvBufferActualSize, gGeneralTransceiveTimeout); + + //copy results back to java + result = e->NewByteArray (recvBufferActualSize); + if (result != NULL) + { + e->SetByteArrayRegion (result, 0, recvBufferActualSize, (jbyte *) recvBuffer); + } + + e->ReleaseByteArrayElements (data, (jbyte *) buf, JNI_ABORT); + ALOGD("%s: exit: recv len=%ld", __FUNCTION__, recvBufferActualSize); + return result; +} + + +/******************************************************************************* +** +** Function: nativeNfcSecureElement_doGetUid +** +** Description: Get the secure element's unique ID. +** e: JVM environment. +** o: Java object. +** handle: Handle of secure element. +** +** Returns: Secure element's unique ID. +** +*******************************************************************************/ +static jbyteArray nativeNfcSecureElement_doGetUid (JNIEnv* e, jobject o, jint handle) +{ + ALOGD("%s: enter; handle=0x%X", __FUNCTION__, handle); + jbyteArray secureElementUid = NULL; + + SecureElement::getInstance ().getUiccId (handle, secureElementUid); + + ALOGD("%s: exit", __FUNCTION__); + return secureElementUid; +} + + +/******************************************************************************* +** +** Function: nativeNfcSecureElement_doGetTechList +** +** Description: Get a list of technologies that the secure element supports. +** e: JVM environment. +** o: Java object. +** handle: Handle of secure element. +** +** Returns: Array of technologies. +** +*******************************************************************************/ +static jintArray nativeNfcSecureElement_doGetTechList (JNIEnv* e, jobject o, jint handle) +{ + ALOGD("%s: enter; handle=0x%X", __FUNCTION__, handle); + jintArray techList = NULL; + + SecureElement::getInstance().getTechnologyList (handle, techList); + + ALOGD("%s: exit", __FUNCTION__); + return techList; +} + + +/***************************************************************************** +** +** Description: JNI functions +** +*****************************************************************************/ +static JNINativeMethod gMethods[] = +{ + {"doNativeOpenSecureElementConnection", "()I", (void *) nativeNfcSecureElement_doOpenSecureElementConnection}, + {"doNativeDisconnectSecureElementConnection", "(I)Z", (void *) nativeNfcSecureElement_doDisconnectSecureElementConnection}, + {"doTransceive", "(I[B)[B", (void *) nativeNfcSecureElement_doTransceive}, + {"doGetUid", "(I)[B", (void *) nativeNfcSecureElement_doGetUid}, + {"doGetTechList", "(I)[I", (void *) nativeNfcSecureElement_doGetTechList}, +}; + + +/******************************************************************************* +** +** Function: register_com_android_nfc_NativeNfcSecureElement +** +** Description: Regisgter JNI functions with Java Virtual Machine. +** e: Environment of JVM. +** +** Returns: Status of registration. +** +*******************************************************************************/ +int register_com_android_nfc_NativeNfcSecureElement(JNIEnv *e) +{ + return jniRegisterNativeMethods(e, gNativeNfcSecureElementClassName, + gMethods, NELEM(gMethods)); +} + + +} // namespace android + diff --git a/nci/jni/NfcJniUtil.cpp b/nci/jni/NfcJniUtil.cpp new file mode 100755 index 0000000..9921cae --- /dev/null +++ b/nci/jni/NfcJniUtil.cpp @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "NfcJniUtil.h" +#include + + +/******************************************************************************* +** +** Function: JNI_OnLoad +** +** Description: Register all JNI functions with Java Virtual Machine. +** jvm: Java Virtual Machine. +** reserved: Not used. +** +** Returns: JNI version. +** +*******************************************************************************/ +jint JNI_OnLoad (JavaVM *jvm, void *reserved) +{ + ALOGD ("%s: enter", __FUNCTION__); + JNIEnv *e = NULL; + + // Check JNI version + if (jvm->GetEnv ((void **) &e, JNI_VERSION_1_6)) + return JNI_ERR; + + if (android::register_com_android_nfc_NativeNfcManager (e) == -1) + return JNI_ERR; + if (android::register_com_android_nfc_NativeLlcpServiceSocket (e) == -1) + return JNI_ERR; + if (android::register_com_android_nfc_NativeLlcpSocket (e) == -1) + return JNI_ERR; + if (android::register_com_android_nfc_NativeNfcTag (e) == -1) + return JNI_ERR; + if (android::register_com_android_nfc_NativeLlcpConnectionlessSocket (e) == -1) + return JNI_ERR; + if (android::register_com_android_nfc_NativeP2pDevice (e) == -1) + return JNI_ERR; + if (android::register_com_android_nfc_NativeNfcSecureElement (e) == -1) + return JNI_ERR; + ALOGD ("%s: exit", __FUNCTION__); + return JNI_VERSION_1_6; +} + + +namespace android +{ + + +/******************************************************************************* +** +** Function: nfc_jni_cache_object +** +** Description: +** +** Returns: Status code. +** +*******************************************************************************/ +int nfc_jni_cache_object (JNIEnv *e, const char *className, jobject *cachedObj) +{ + jclass cls = NULL; + jobject obj = NULL; + jmethodID ctor = 0; + + cls = e->FindClass (className); + if(cls == NULL) + { + ALOGE ("%s: find class error", __FUNCTION__); + return -1; + } + + ctor = e->GetMethodID (cls, "", "()V"); + obj = e->NewObject (cls, ctor); + if (obj == NULL) + { + ALOGE ("%s: create object error", __FUNCTION__); + return -1; + } + + *cachedObj = e->NewGlobalRef (obj); + if (*cachedObj == NULL) + { + e->DeleteLocalRef (obj); + ALOGE ("%s: global ref error", __FUNCTION__); + return -1; + } + e->DeleteLocalRef (obj); + return 0; +} + + +/******************************************************************************* +** +** Function: nfc_jni_get_nfc_socket_handle +** +** Description: Get the value of "mHandle" member variable. +** e: JVM environment. +** o: Java object. +** +** Returns: Value of mHandle. +** +*******************************************************************************/ +int nfc_jni_get_nfc_socket_handle (JNIEnv *e, jobject o) +{ + jclass c = NULL; + jfieldID f = 0; + + c = e->GetObjectClass (o); + f = e->GetFieldID (c, "mHandle", "I"); + return e->GetIntField (o, f); +} + + +/******************************************************************************* +** +** Function: nfc_jni_get_nat +** +** Description: Get the value of "mNative" member variable. +** e: JVM environment. +** o: Java object. +** +** Returns: Pointer to the value of mNative. +** +*******************************************************************************/ +struct nfc_jni_native_data* nfc_jni_get_nat(JNIEnv *e, jobject o) +{ + jclass c = NULL; + jfieldID f = 0; + + /* Retrieve native structure address */ + c = e->GetObjectClass(o); + f = e->GetFieldID(c, "mNative", "I"); + return (struct nfc_jni_native_data*)e->GetIntField(o, f); +} + + +} // namespace android diff --git a/nci/jni/NfcJniUtil.h b/nci/jni/NfcJniUtil.h new file mode 100755 index 0000000..8caa0b8 --- /dev/null +++ b/nci/jni/NfcJniUtil.h @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once +#define LOG_TAG "BrcmNfcJni" +#include +#include +#include +#include +#include + + +/* Discovery modes -- keep in sync with NFCManager.DISCOVERY_MODE_* */ +#define DISCOVERY_MODE_TAG_READER 0 +#define DISCOVERY_MODE_NFCIP1 1 +#define DISCOVERY_MODE_CARD_EMULATION 2 +#define DISCOVERY_MODE_TABLE_SIZE 3 + +#define DISCOVERY_MODE_DISABLED 0 +#define DISCOVERY_MODE_ENABLED 1 + +#define MODE_P2P_TARGET 0 +#define MODE_P2P_INITIATOR 1 + + +/* Properties values */ +#define PROPERTY_LLCP_LTO 0 +#define PROPERTY_LLCP_MIU 1 +#define PROPERTY_LLCP_WKS 2 +#define PROPERTY_LLCP_OPT 3 +#define PROPERTY_NFC_DISCOVERY_A 4 +#define PROPERTY_NFC_DISCOVERY_B 5 +#define PROPERTY_NFC_DISCOVERY_F 6 +#define PROPERTY_NFC_DISCOVERY_15693 7 +#define PROPERTY_NFC_DISCOVERY_NCFIP 8 + + +/* Error codes */ +#define ERROR_BUFFER_TOO_SMALL -12 +#define ERROR_INSUFFICIENT_RESOURCES -9 + + +/* Pre-defined tag type values. These must match the values in + * Ndef.java in the framework. + */ +#define NDEF_UNKNOWN_TYPE -1 +#define NDEF_TYPE1_TAG 1 +#define NDEF_TYPE2_TAG 2 +#define NDEF_TYPE3_TAG 3 +#define NDEF_TYPE4_TAG 4 +#define NDEF_MIFARE_CLASSIC_TAG 101 + + +/* Pre-defined card read/write state values. These must match the values in + * Ndef.java in the framework. + */ +#define NDEF_MODE_READ_ONLY 1 +#define NDEF_MODE_READ_WRITE 2 +#define NDEF_MODE_UNKNOWN 3 + + +/* Name strings for target types. These *must* match the values in TagTechnology.java */ +#define TARGET_TYPE_UNKNOWN -1 +#define TARGET_TYPE_ISO14443_3A 1 +#define TARGET_TYPE_ISO14443_3B 2 +#define TARGET_TYPE_ISO14443_4 3 +#define TARGET_TYPE_FELICA 4 +#define TARGET_TYPE_ISO15693 5 +#define TARGET_TYPE_NDEF 6 +#define TARGET_TYPE_NDEF_FORMATABLE 7 +#define TARGET_TYPE_MIFARE_CLASSIC 8 +#define TARGET_TYPE_MIFARE_UL 9 + + +//define a few NXP error codes that NFC service expects; +//see external/libnfc-nxp/src/phLibNfcStatus.h; +//see external/libnfc-nxp/inc/phNfcStatus.h +#define NFCSTATUS_SUCCESS (0x0000) +#define NFCSTATUS_FAILED (0x00FF) + +//default general trasceive timeout in millisecond +#define DEFAULT_GENERAL_TRANS_TIMEOUT 1000 + +struct nfc_jni_native_data +{ + /* Thread handle */ + pthread_t thread; + int running; + + /* Our VM */ + JavaVM *vm; + int env_version; + + /* Reference to the NFCManager instance */ + jobject manager; + + /* Cached objects */ + jobject cached_NfcTag; + jobject cached_P2pDevice; + + /* Secure Element selected */ + int seId; + + /* LLCP params */ + int lto; + int miu; + int wks; + int opt; + + int tech_mask; + + /* Tag detected */ + jobject tag; + + int tHandle; + int tProtocols[16]; + int handles[16]; +}; + + +extern "C" +{ + jint JNI_OnLoad(JavaVM *jvm, void *reserved); +} + + +namespace android +{ + int nfc_jni_cache_object (JNIEnv *e, const char *clsname, jobject *cached_obj); + int nfc_jni_get_nfc_socket_handle (JNIEnv *e, jobject o); + struct nfc_jni_native_data* nfc_jni_get_nat (JNIEnv *e, jobject o); + int register_com_android_nfc_NativeNfcManager (JNIEnv *e); + int register_com_android_nfc_NativeNfcTag (JNIEnv *e); + int register_com_android_nfc_NativeP2pDevice (JNIEnv *e); + int register_com_android_nfc_NativeLlcpConnectionlessSocket (JNIEnv *e); + int register_com_android_nfc_NativeLlcpServiceSocket (JNIEnv *e); + int register_com_android_nfc_NativeLlcpSocket (JNIEnv *e); + int register_com_android_nfc_NativeNfcSecureElement (JNIEnv *e); +} // namespace android diff --git a/nci/jni/NfcTag.cpp b/nci/jni/NfcTag.cpp new file mode 100755 index 0000000..b94355f --- /dev/null +++ b/nci/jni/NfcTag.cpp @@ -0,0 +1,1325 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Tag-reading, tag-writing operations. + */ +#include "OverrideLog.h" +#include "NfcTag.h" +#include "JavaClassConstants.h" +extern "C" +{ + #include "rw_int.h" +} + + +/******************************************************************************* +** +** Function: NfcTag +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +NfcTag::NfcTag () +: mNativeData (NULL), + mActivationState (Idle), + mProtocol(NFC_PROTOCOL_UNKNOWN), + mNumTechList (0), + mtT1tMaxMessageSize (0), + mReadCompletedStatus (NFA_STATUS_OK), + mLastKovioUidLen (0), + mNdefDetectionTimedOut (false) +{ + memset (mTechList, 0, sizeof(mTechList)); + memset (mTechHandles, 0, sizeof(mTechHandles)); + memset (mTechLibNfcTypes, 0, sizeof(mTechLibNfcTypes)); + memset (mTechParams, 0, sizeof(mTechParams)); + memset(mLastKovioUid, 0, NFC_KOVIO_MAX_LEN); +} + + +/******************************************************************************* +** +** Function: getInstance +** +** Description: Get a reference to the singleton NfcTag object. +** +** Returns: Reference to NfcTag object. +** +*******************************************************************************/ +NfcTag& NfcTag::getInstance () +{ + static NfcTag tag; + return tag; +} + + +/******************************************************************************* +** +** Function: initialize +** +** Description: Reset member variables. +** native: Native data. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::initialize (nfc_jni_native_data* native) +{ + mNativeData = native; + mActivationState = Idle; + mProtocol = NFC_PROTOCOL_UNKNOWN; + mNumTechList = 0; + mtT1tMaxMessageSize = 0; + mReadCompletedStatus = NFA_STATUS_OK; + resetTechnologies (); +} + + +/******************************************************************************* +** +** Function: abort +** +** Description: Unblock all operations. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::abort () +{ + SyncEventGuard g (mReadCompleteEvent); + mReadCompleteEvent.notifyOne (); +} + + +/******************************************************************************* +** +** Function: getActivationState +** +** Description: What is the current state: Idle, Sleep, or Activated. +** +** Returns: Idle, Sleep, or Activated. +** +*******************************************************************************/ +NfcTag::ActivationState NfcTag::getActivationState () +{ + return mActivationState; +} + + +/******************************************************************************* +** +** Function: setDeactivationState +** +** Description: Set the current state: Idle or Sleep. +** deactivated: state of deactivation. +** +** Returns: None. +** +*******************************************************************************/ +void NfcTag::setDeactivationState (tNFA_DEACTIVATED& deactivated) +{ + static const char fn [] = "NfcTag::setDeactivationState"; + mActivationState = Idle; + mNdefDetectionTimedOut = false; + if (deactivated.type == NFA_DEACTIVATE_TYPE_SLEEP) + mActivationState = Sleep; + ALOGD ("%s: state=%u", fn, mActivationState); +} + + +/******************************************************************************* +** +** Function: setActivationState +** +** Description: Set the current state to Active. +** +** Returns: None. +** +*******************************************************************************/ +void NfcTag::setActivationState () +{ + static const char fn [] = "NfcTag::setActivationState"; + mNdefDetectionTimedOut = false; + mActivationState = Active; + ALOGD ("%s: state=%u", fn, mActivationState); +} + + +/******************************************************************************* +** +** Function: getProtocol +** +** Description: Get the protocol of the current tag. +** +** Returns: Protocol number. +** +*******************************************************************************/ +tNFC_PROTOCOL NfcTag::getProtocol() +{ + return mProtocol; +} + +/******************************************************************************* +** +** Function TimeDiff +** +** Description Computes time difference in milliseconds. +** +** Returns Time difference in milliseconds +** +*******************************************************************************/ +UINT32 TimeDiff(timespec start, timespec end) +{ + timespec temp; + if ((end.tv_nsec-start.tv_nsec)<0) + { + temp.tv_sec = end.tv_sec-start.tv_sec-1; + temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec; + } + else + { + temp.tv_sec = end.tv_sec-start.tv_sec; + temp.tv_nsec = end.tv_nsec-start.tv_nsec; + } + + return (temp.tv_sec * 1000) + (temp.tv_nsec / 1000000); +} + +/******************************************************************************* +** +** Function: IsSameKovio +** +** Description: Checks if tag activate is the same (UID) Kovio tag previously +** activated. This is needed due to a problem with some Kovio +** tags re-activating multiple times. +** activationData: data from activation. +** +** Returns: true if the activation is from the same tag previously +** activated, false otherwise +** +*******************************************************************************/ +bool NfcTag::IsSameKovio(tNFA_ACTIVATED& activationData) +{ + static const char fn [] = "NfcTag::IsSameKovio"; + ALOGD ("%s: enter", fn); + tNFC_ACTIVATE_DEVT& rfDetail = activationData.activate_ntf; + + if (rfDetail.protocol != NFC_PROTOCOL_KOVIO) + return false; + + memcpy (&(mTechParams[0]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); + if (mTechParams [0].mode != NFC_DISCOVERY_TYPE_POLL_KOVIO) + return false; + + struct timespec now; + clock_gettime(CLOCK_REALTIME, &now); + + bool rVal = false; + if (mTechParams[0].param.pk.uid_len == mLastKovioUidLen) + { + if (memcmp(mLastKovioUid, &mTechParams [0].param.pk.uid, mTechParams[0].param.pk.uid_len) == 0) + { + //same tag + if (TimeDiff(mLastKovioTime, now) < 500) + { + // same tag within 500 ms, ignore activation + rVal = true; + } + } + } + + // save Kovio tag info + if (!rVal) + { + if ((mLastKovioUidLen = mTechParams[0].param.pk.uid_len) > NFC_KOVIO_MAX_LEN) + mLastKovioUidLen = NFC_KOVIO_MAX_LEN; + memcpy(mLastKovioUid, mTechParams[0].param.pk.uid, mLastKovioUidLen); + } + mLastKovioTime = now; + ALOGD ("%s: exit, is same Kovio=%d", fn, rVal); + return rVal; +} + +/******************************************************************************* +** +** Function: discoverTechnologies +** +** Description: Discover the technologies that NFC service needs by interpreting +** the data strucutures from the stack. +** activationData: data from activation. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::discoverTechnologies (tNFA_ACTIVATED& activationData) +{ + static const char fn [] = "NfcTag::discoverTechnologies (activation)"; + ALOGD ("%s: enter", fn); + tNFC_ACTIVATE_DEVT& rfDetail = activationData.activate_ntf; + + mNumTechList = 0; + mTechHandles [mNumTechList] = rfDetail.rf_disc_id; + mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; + + //save the stack's data structure for interpretation later + memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); + + switch (rfDetail.protocol) + { + case NFC_PROTOCOL_T1T: + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API + break; + + case NFC_PROTOCOL_T2T: + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API + // could be MifFare UL or Classic or Kovio + { + // need to look at first byte of uid to find manuf. + tNFC_RF_TECH_PARAMS tech_params; + memcpy (&tech_params, &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); + + if ((tech_params.param.pa.nfcid1[0] == 0x04 && rfDetail.rf_tech_param.param.pa.sel_rsp == 0) || + rfDetail.rf_tech_param.param.pa.sel_rsp == 0x18 || + rfDetail.rf_tech_param.param.pa.sel_rsp == 0x08) + { + if (rfDetail.rf_tech_param.param.pa.sel_rsp == 0) + { + mNumTechList++; + mTechHandles [mNumTechList] = rfDetail.rf_disc_id; + mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; + //save the stack's data structure for interpretation later + memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); + mTechList [mNumTechList] = TARGET_TYPE_MIFARE_UL; //is TagTechnology.MIFARE_ULTRALIGHT by Java API + } + } + } + break; + + case NFC_PROTOCOL_T3T: + mTechList [mNumTechList] = TARGET_TYPE_FELICA; + break; + + case NFC_PROTOCOL_ISO_DEP: //type-4 tag uses technology ISO-DEP and technology A or B + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_4; //is TagTechnology.ISO_DEP by Java API + if ( (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) || + (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) || + (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A) || + (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ) + { + mNumTechList++; + mTechHandles [mNumTechList] = rfDetail.rf_disc_id; + mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API + //save the stack's data structure for interpretation later + memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); + } + else if ( (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B) || + (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B_PRIME) || + (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B) || + (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) ) + { + mNumTechList++; + mTechHandles [mNumTechList] = rfDetail.rf_disc_id; + mTechLibNfcTypes [mNumTechList] = rfDetail.protocol; + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3B; //is TagTechnology.NFC_B by Java API + //save the stack's data structure for interpretation later + memcpy (&(mTechParams[mNumTechList]), &(rfDetail.rf_tech_param), sizeof(rfDetail.rf_tech_param)); + } + break; + + case NFC_PROTOCOL_15693: //is TagTechnology.NFC_V by Java API + mTechList [mNumTechList] = TARGET_TYPE_ISO15693; + break; + + case NFC_PROTOCOL_KOVIO: + ALOGE ("%s: Kovio", fn); + mNumTechList--; // no tech classes for Kovio + break; + + default: + ALOGE ("%s: unknown protocol ????", fn); + mTechList [mNumTechList] = TARGET_TYPE_UNKNOWN; + break; + } + + mNumTechList++; + for (int i=0; i < mNumTechList; i++) + { + ALOGD ("%s: index=%d; tech=%d; handle=%d; nfc type=%d", fn, + i, mTechList[i], mTechHandles[i], mTechLibNfcTypes[i]); + } + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: discoverTechnologies +** +** Description: Discover the technologies that NFC service needs by interpreting +** the data strucutures from the stack. +** discoveryData: data from discovery events(s). +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::discoverTechnologies (tNFA_DISC_RESULT& discoveryData) +{ + static const char fn [] = "NfcTag::discoverTechnologies (discovery)"; + tNFC_RESULT_DEVT& discovery_ntf = discoveryData.discovery_ntf; + + ALOGD ("%s: enter: rf disc. id=%u; protocol=%u, mNumTechList=%u", fn, discovery_ntf.rf_disc_id, discovery_ntf.protocol, mNumTechList); + if (mNumTechList >= MAX_NUM_TECHNOLOGY) + { + ALOGE ("%s: exceed max=%d", fn, MAX_NUM_TECHNOLOGY); + goto TheEnd; + } + mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; + mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; + + //save the stack's data structure for interpretation later + memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); + + switch (discovery_ntf.protocol) + { + case NFC_PROTOCOL_T1T: + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API + break; + + case NFC_PROTOCOL_T2T: + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API + //type-2 tags are identitical to Mifare Ultralight, so Ultralight is also discovered + if (discovery_ntf.rf_tech_param.param.pa.sel_rsp == 0) + { + // mifare Ultralight + mNumTechList++; + mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; + mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; + mTechList [mNumTechList] = TARGET_TYPE_MIFARE_UL; //is TagTechnology.MIFARE_ULTRALIGHT by Java API + } + + //save the stack's data structure for interpretation later + memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); + break; + + case NFC_PROTOCOL_T3T: + mTechList [mNumTechList] = TARGET_TYPE_FELICA; + break; + + case NFC_PROTOCOL_ISO_DEP: //type-4 tag uses technology ISO-DEP and technology A or B + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_4; //is TagTechnology.ISO_DEP by Java API + if ( (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) || + (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) || + (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A) || + (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ) + { + mNumTechList++; + mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; + mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3A; //is TagTechnology.NFC_A by Java API + //save the stack's data structure for interpretation later + memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); + } + else if ( (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B) || + (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B_PRIME) || + (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B) || + (discovery_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) ) + { + mNumTechList++; + mTechHandles [mNumTechList] = discovery_ntf.rf_disc_id; + mTechLibNfcTypes [mNumTechList] = discovery_ntf.protocol; + mTechList [mNumTechList] = TARGET_TYPE_ISO14443_3B; //is TagTechnology.NFC_B by Java API + //save the stack's data structure for interpretation later + memcpy (&(mTechParams[mNumTechList]), &(discovery_ntf.rf_tech_param), sizeof(discovery_ntf.rf_tech_param)); + } + break; + + case NFC_PROTOCOL_15693: //is TagTechnology.NFC_V by Java API + mTechList [mNumTechList] = TARGET_TYPE_ISO15693; + break; + + default: + ALOGE ("%s: unknown protocol ????", fn); + mTechList [mNumTechList] = TARGET_TYPE_UNKNOWN; + break; + } + + mNumTechList++; + if (discovery_ntf.more == FALSE) + { + for (int i=0; i < mNumTechList; i++) + { + ALOGD ("%s: index=%d; tech=%d; handle=%d; nfc type=%d", fn, + i, mTechList[i], mTechHandles[i], mTechLibNfcTypes[i]); + } + } + +TheEnd: + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: createNativeNfcTag +** +** Description: Create a brand new Java NativeNfcTag object; +** fill the objects's member variables with data; +** notify NFC service; +** activationData: data from activation. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::createNativeNfcTag (tNFA_ACTIVATED& activationData) +{ + static const char fn [] = "NfcTag::createNativeNfcTag"; + ALOGD ("%s: enter", fn); + JNIEnv* e = NULL; + jclass tag_cls = NULL; + jmethodID ctor = NULL; + jobject tag = NULL; + + //acquire a pointer to the Java virtual machine + mNativeData->vm->AttachCurrentThread (&e, NULL); + if (e == NULL) + { + ALOGE("%s: jni env is null", fn); + goto TheEnd; + } + + tag_cls = e->GetObjectClass (mNativeData->cached_NfcTag); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE("%s: failed to get class", fn); + goto TheEnd; + } + + //create a new Java NativeNfcTag object + ctor = e->GetMethodID (tag_cls, "", "()V"); + tag = e->NewObject (tag_cls, ctor); + + //fill NativeNfcTag's mProtocols, mTechList, mTechHandles, mTechLibNfcTypes + fillNativeNfcTagMembers1 (e, tag_cls, tag); + + //fill NativeNfcTag's members: mHandle, mConnectedTechnology + fillNativeNfcTagMembers2 (e, tag_cls, tag, activationData); + + //fill NativeNfcTag's members: mTechPollBytes + fillNativeNfcTagMembers3 (e, tag_cls, tag, activationData); + + //fill NativeNfcTag's members: mTechActBytes + fillNativeNfcTagMembers4 (e, tag_cls, tag, activationData); + + //fill NativeNfcTag's members: mUid + fillNativeNfcTagMembers5 (e, tag_cls, tag, activationData); + + if (mNativeData->tag != NULL) { + e->DeleteGlobalRef (mNativeData->tag); + } + mNativeData->tag = e->NewGlobalRef (tag); + + //notify NFC service about this new tag + ALOGD ("%s: try notify nfc service", fn); + e->CallVoidMethod (mNativeData->manager, android::gCachedNfcManagerNotifyNdefMessageListeners, tag); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail notify nfc service", fn); + } + e->DeleteLocalRef (tag); + +TheEnd: + mNativeData->vm->DetachCurrentThread (); + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: fillNativeNfcTagMembers1 +** +** Description: Fill NativeNfcTag's members: mProtocols, mTechList, mTechHandles, mTechLibNfcTypes. +** e: JVM environment. +** tag_cls: Java NativeNfcTag class. +** tag: Java NativeNfcTag object. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::fillNativeNfcTagMembers1 (JNIEnv* e, jclass tag_cls, jobject tag) +{ + static const char fn [] = "NfcTag::fillNativeNfcTagMembers1"; + ALOGD ("%s", fn); + jfieldID f = NULL; + + //create objects that represent NativeNfcTag's member variables + jintArray techList = e->NewIntArray (mNumTechList); + jintArray handleList = e->NewIntArray (mNumTechList); + jintArray typeList = e->NewIntArray (mNumTechList); + + jint* technologies = e->GetIntArrayElements (techList, NULL); + jint* handles = e->GetIntArrayElements (handleList, NULL); + jint* types = e->GetIntArrayElements (typeList, NULL); + for (int i = 0; i < mNumTechList; i++) + { + mNativeData->tProtocols [i] = mTechLibNfcTypes [i]; + mNativeData->handles [i] = mTechHandles [i]; + technologies [i] = mTechList [i]; + handles [i] = mTechHandles [i]; + types [i] = mTechLibNfcTypes [i]; + } + e->ReleaseIntArrayElements (techList, technologies, 0); + e->ReleaseIntArrayElements (handleList, handles, 0); + e->ReleaseIntArrayElements (typeList, types, 0); + + f = e->GetFieldID (tag_cls, "mTechList", "[I"); + e->SetObjectField (tag, f, techList); + + f = e->GetFieldID (tag_cls, "mTechHandles", "[I"); + e->SetObjectField (tag, f, handleList); + + f = e->GetFieldID (tag_cls, "mTechLibNfcTypes", "[I"); + e->SetObjectField (tag, f, typeList); +} + + +/******************************************************************************* +** +** Function: fillNativeNfcTagMembers2 +** +** Description: Fill NativeNfcTag's members: mConnectedTechIndex or mConnectedTechnology. +** The original Google's implementation is in set_target_pollBytes( +** in com_android_nfc_NativeNfcTag.cpp; +** e: JVM environment. +** tag_cls: Java NativeNfcTag class. +** tag: Java NativeNfcTag object. +** activationData: data from activation. +** +** Returns: None +** +*******************************************************************************/ +//fill NativeNfcTag's members: mHandle, mConnectedTechnology +void NfcTag::fillNativeNfcTagMembers2 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData) +{ + static const char fn [] = "NfcTag::fillNativeNfcTagMembers2"; + ALOGD ("%s", fn); + jfieldID f = NULL; + + f = e->GetFieldID (tag_cls, "mConnectedTechIndex", "I"); + e->SetIntField (tag, f, (jint) 0); +} + + +/******************************************************************************* +** +** Function: fillNativeNfcTagMembers3 +** +** Description: Fill NativeNfcTag's members: mTechPollBytes. +** The original Google's implementation is in set_target_pollBytes( +** in com_android_nfc_NativeNfcTag.cpp; +** e: JVM environment. +** tag_cls: Java NativeNfcTag class. +** tag: Java NativeNfcTag object. +** activationData: data from activation. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::fillNativeNfcTagMembers3 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData) +{ + static const char fn [] = "NfcTag::fillNativeNfcTagMembers3"; + jfieldID f = NULL; + jbyteArray pollBytes = e->NewByteArray (0); + jobjectArray techPollBytes = e->NewObjectArray (mNumTechList, e->GetObjectClass(pollBytes), 0); + int len = 0; + + for (int i = 0; i < mNumTechList; i++) + { + ALOGD ("%s: index=%d; rf tech params mode=%u", fn, i, mTechParams [i].mode); + switch (mTechParams [i].mode) + { + case NFC_DISCOVERY_TYPE_POLL_A: + case NFC_DISCOVERY_TYPE_POLL_A_ACTIVE: + case NFC_DISCOVERY_TYPE_LISTEN_A: + case NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE: + ALOGD ("%s: tech A", fn); + pollBytes = e->NewByteArray (2); + e->SetByteArrayRegion (pollBytes, 0, 2, + (jbyte*) mTechParams [i].param.pa.sens_res); + break; + + case NFC_DISCOVERY_TYPE_POLL_B: + case NFC_DISCOVERY_TYPE_POLL_B_PRIME: + case NFC_DISCOVERY_TYPE_LISTEN_B: + case NFC_DISCOVERY_TYPE_LISTEN_B_PRIME: + if (mTechList [i] == TARGET_TYPE_ISO14443_3B) //is TagTechnology.NFC_B by Java API + { + /***************** + see NFC Forum Digital Protocol specification; section 5.6.2; + in SENSB_RES response, byte 6 through 9 is Application Data, byte 10-12 or 13 is Protocol Info; + used by public API: NfcB.getApplicationData(), NfcB.getProtocolInfo(); + *****************/ + ALOGD ("%s: tech B; TARGET_TYPE_ISO14443_3B", fn); + len = mTechParams [i].param.pb.sensb_res_len; + len = len - 4; //subtract 4 bytes for NFCID0 at byte 2 through 5 + pollBytes = e->NewByteArray (len); + e->SetByteArrayRegion (pollBytes, 0, len, (jbyte*) (mTechParams [i].param.pb.sensb_res+4)); + } + else + pollBytes = e->NewByteArray (0); + break; + + case NFC_DISCOVERY_TYPE_POLL_F: + case NFC_DISCOVERY_TYPE_POLL_F_ACTIVE: + case NFC_DISCOVERY_TYPE_LISTEN_F: + case NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE: + { + /**************** + see NFC Forum Type 3 Tag Operation Specification; sections 2.3.2, 2.3.1.2; + see NFC Forum Digital Protocol Specification; sections 6.6.2; + PMm: manufacture parameter; 8 bytes; + System Code: 2 bytes; + ****************/ + ALOGD ("%s: tech F", fn); + UINT8 result [10]; //return result to NFC service + memset (result, 0, sizeof(result)); + len = 10; + + /**** + for (int ii = 0; ii < mTechParams [i].param.pf.sensf_res_len; ii++) + { + ALOGD ("%s: tech F, sendf_res[%d]=%d (0x%x)", + fn, ii, mTechParams [i].param.pf.sensf_res[ii],mTechParams [i].param.pf.sensf_res[ii]); + } + ***/ + memcpy (result, mTechParams [i].param.pf.sensf_res + 8, 8); //copy PMm + if (activationData.params.t3t.num_system_codes > 0) //copy the first System Code + { + UINT16 systemCode = *(activationData.params.t3t.p_system_codes); + result [8] = (UINT8) (systemCode >> 8); + result [9] = (UINT8) systemCode; + ALOGD ("%s: tech F; sys code=0x%X 0x%X", fn, result [8], result [9]); + } + pollBytes = e->NewByteArray (len); + e->SetByteArrayRegion (pollBytes, 0, len, (jbyte*) result); + } + break; + + case NFC_DISCOVERY_TYPE_POLL_ISO15693: + case NFC_DISCOVERY_TYPE_LISTEN_ISO15693: + { + ALOGD ("%s: tech iso 15693", fn); + //iso 15693 response flags: 1 octet + //iso 15693 Data Structure Format Identifier (DSF ID): 1 octet + //used by public API: NfcV.getDsfId(), NfcV.getResponseFlags(); + uint8_t data [2]= {activationData.params.i93.afi, activationData.params.i93.dsfid}; + pollBytes = e->NewByteArray (2); + e->SetByteArrayRegion (pollBytes, 0, 2, (jbyte *) data); + } + break; + + default: + ALOGE ("%s: tech unknown ????", fn); + pollBytes = e->NewByteArray(0); + break; + } //switch: every type of technology + e->SetObjectArrayElement (techPollBytes, i, pollBytes); + } //for: every technology in the array + f = e->GetFieldID (tag_cls, "mTechPollBytes", "[[B"); + e->SetObjectField (tag, f, techPollBytes); +} + + +/******************************************************************************* +** +** Function: fillNativeNfcTagMembers4 +** +** Description: Fill NativeNfcTag's members: mTechActBytes. +** The original Google's implementation is in set_target_activationBytes() +** in com_android_nfc_NativeNfcTag.cpp; +** e: JVM environment. +** tag_cls: Java NativeNfcTag class. +** tag: Java NativeNfcTag object. +** activationData: data from activation. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::fillNativeNfcTagMembers4 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData) +{ + static const char fn [] = "NfcTag::fillNativeNfcTagMembers4"; + jfieldID f = NULL; + jbyteArray actBytes = e->NewByteArray (0); + jobjectArray techActBytes = e->NewObjectArray (mNumTechList, e->GetObjectClass(actBytes), 0); + jbyteArray uid = NULL; + int len = 0; + + for (int i = 0; i < mNumTechList; i++) + { + ALOGD ("%s: index=%d", fn, i); + switch (mTechLibNfcTypes[i]) + { + case NFC_PROTOCOL_T1T: + { + ALOGD ("%s: T1T; tech A", fn); + actBytes = e->NewByteArray (1); + e->SetByteArrayRegion (actBytes, 0, 1, + (jbyte*) &mTechParams [i].param.pa.sel_rsp); + } + break; + + case NFC_PROTOCOL_T2T: + { + ALOGD ("%s: T2T; tech A", fn); + actBytes = e->NewByteArray (1); + e->SetByteArrayRegion (actBytes, 0, 1, + (jbyte*) &mTechParams [i].param.pa.sel_rsp); + } + break; + + case NFC_PROTOCOL_T3T: //felica + { + ALOGD ("%s: T3T; felica; tech F", fn); + //really, there is no data + actBytes = e->NewByteArray (0); + } + break; + + case NFC_PROTOCOL_ISO_DEP: //t4t + { + if (mTechList [i] == TARGET_TYPE_ISO14443_4) //is TagTechnology.ISO_DEP by Java API + { + if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_A) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ) + { + //see NFC Forum Digital Protocol specification, section 11.6.2, "RATS Response"; search for "historical bytes"; + //copy historical bytes into Java object; + //the public API, IsoDep.getHistoricalBytes(), returns this data; + if (activationData.activate_ntf.intf_param.type == NFC_INTERFACE_ISO_DEP) + { + tNFC_INTF_PA_ISO_DEP& pa_iso = activationData.activate_ntf.intf_param.intf_param.pa_iso; + ALOGD ("%s: T4T; ISO_DEP for tech A; copy historical bytes; len=%u", fn, pa_iso.his_byte_len); + actBytes = e->NewByteArray (pa_iso.his_byte_len); + if (pa_iso.his_byte_len > 0) + e->SetByteArrayRegion (actBytes, 0, pa_iso.his_byte_len, (jbyte*) (pa_iso.his_byte)); + } + else + { + ALOGE ("%s: T4T; ISO_DEP for tech A; wrong interface=%u", fn, activationData.activate_ntf.intf_param.type); + actBytes = e->NewByteArray (0); + } + } + else if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_B) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_B_PRIME) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_B) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) ) + { + //see NFC Forum Digital Protocol specification, section 12.6.2, "ATTRIB Response"; + //copy higher-layer response bytes into Java object; + //the public API, IsoDep.getHiLayerResponse(), returns this data; + if (activationData.activate_ntf.intf_param.type == NFC_INTERFACE_ISO_DEP) + { + tNFC_INTF_PB_ISO_DEP& pb_iso = activationData.activate_ntf.intf_param.intf_param.pb_iso; + ALOGD ("%s: T4T; ISO_DEP for tech B; copy response bytes; len=%u", fn, pb_iso.hi_info_len); + actBytes = e->NewByteArray (pb_iso.hi_info_len); + if (pb_iso.hi_info_len > 0) + e->SetByteArrayRegion (actBytes, 0, pb_iso.hi_info_len, (jbyte*) (pb_iso.hi_info)); + } + else + { + ALOGE ("%s: T4T; ISO_DEP for tech B; wrong interface=%u", fn, activationData.activate_ntf.intf_param.type); + actBytes = e->NewByteArray (0); + } + } + } + else if (mTechList [i] == TARGET_TYPE_ISO14443_3A) //is TagTechnology.NFC_A by Java API + { + ALOGD ("%s: T4T; tech A", fn); + actBytes = e->NewByteArray (1); + e->SetByteArrayRegion (actBytes, 0, 1, (jbyte*) &mTechParams [i].param.pa.sel_rsp); + } + else + { + actBytes = e->NewByteArray (0); + } + } //case NFC_PROTOCOL_ISO_DEP: //t4t + break; + + case NFC_PROTOCOL_15693: + { + ALOGD ("%s: tech iso 15693", fn); + //iso 15693 response flags: 1 octet + //iso 15693 Data Structure Format Identifier (DSF ID): 1 octet + //used by public API: NfcV.getDsfId(), NfcV.getResponseFlags(); + uint8_t data [2]= {activationData.params.i93.afi, activationData.params.i93.dsfid}; + actBytes = e->NewByteArray (2); + e->SetByteArrayRegion (actBytes, 0, 2, (jbyte *) data); + } + break; + + default: + ALOGD ("%s: tech unknown ????", fn); + actBytes = e->NewByteArray (0); + break; + }//switch + e->SetObjectArrayElement (techActBytes, i, actBytes); + } //for: every technology in the array + f = e->GetFieldID (tag_cls, "mTechActBytes", "[[B"); + e->SetObjectField (tag, f, techActBytes); +} + + +/******************************************************************************* +** +** Function: fillNativeNfcTagMembers5 +** +** Description: Fill NativeNfcTag's members: mUid. +** The original Google's implementation is in nfc_jni_Discovery_notification_callback() +** in com_android_nfc_NativeNfcManager.cpp; +** e: JVM environment. +** tag_cls: Java NativeNfcTag class. +** tag: Java NativeNfcTag object. +** activationData: data from activation. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::fillNativeNfcTagMembers5 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData) +{ + static const char fn [] = "NfcTag::fillNativeNfcTagMembers5"; + jfieldID f = NULL; + int len = 0; + jbyteArray uid = NULL; + + switch (mTechParams [0].mode) + { + case NFC_DISCOVERY_TYPE_POLL_KOVIO: + ALOGD ("%s: Kovio", fn); + len = mTechParams [0].param.pk.uid_len; + uid = e->NewByteArray (len); + e->SetByteArrayRegion (uid, 0, len, + (jbyte*) &mTechParams [0].param.pk.uid); + break; + + case NFC_DISCOVERY_TYPE_POLL_A: + case NFC_DISCOVERY_TYPE_POLL_A_ACTIVE: + case NFC_DISCOVERY_TYPE_LISTEN_A: + case NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE: + ALOGD ("%s: tech A", fn); + len = mTechParams [0].param.pa.nfcid1_len; + uid = e->NewByteArray (len); + e->SetByteArrayRegion (uid, 0, len, + (jbyte*) &mTechParams [0].param.pa.nfcid1); + break; + + case NFC_DISCOVERY_TYPE_POLL_B: + case NFC_DISCOVERY_TYPE_POLL_B_PRIME: + case NFC_DISCOVERY_TYPE_LISTEN_B: + case NFC_DISCOVERY_TYPE_LISTEN_B_PRIME: + ALOGD ("%s: tech B", fn); + uid = e->NewByteArray (NFC_NFCID0_MAX_LEN); + e->SetByteArrayRegion (uid, 0, NFC_NFCID0_MAX_LEN, + (jbyte*) &mTechParams [0].param.pb.nfcid0); + break; + + case NFC_DISCOVERY_TYPE_POLL_F: + case NFC_DISCOVERY_TYPE_POLL_F_ACTIVE: + case NFC_DISCOVERY_TYPE_LISTEN_F: + case NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE: + ALOGD ("%s: tech F", fn); + uid = e->NewByteArray (NFC_NFCID2_LEN); + e->SetByteArrayRegion (uid, 0, NFC_NFCID2_LEN, + (jbyte*) &mTechParams [0].param.pf.nfcid2); + break; + + case NFC_DISCOVERY_TYPE_POLL_ISO15693: + case NFC_DISCOVERY_TYPE_LISTEN_ISO15693: + { + ALOGD ("%s: tech iso 15693", fn); + jbyte data [I93_UID_BYTE_LEN]; //8 bytes + for (int i=0; iNewByteArray (I93_UID_BYTE_LEN); + e->SetByteArrayRegion (uid, 0, I93_UID_BYTE_LEN, data); + } + break; + + default: + ALOGE ("%s: tech unknown ????", fn); + uid = e->NewByteArray (0); + break; + } //if + f = e->GetFieldID(tag_cls, "mUid", "[B"); + e->SetObjectField(tag, f, uid); +} + + +/******************************************************************************* +** +** Function: isP2pDiscovered +** +** Description: Does the peer support P2P? +** +** Returns: True if the peer supports P2P. +** +*******************************************************************************/ +bool NfcTag::isP2pDiscovered () +{ + static const char fn [] = "NfcTag::isP2pDiscovered"; + bool retval = false; + + for (int i = 0; i < mNumTechList; i++) + { + if (mTechLibNfcTypes[i] == NFA_PROTOCOL_NFC_DEP) + { + //if remote device supports P2P + ALOGD ("%s: discovered P2P", fn); + retval = true; + break; + } + } + ALOGD ("%s: return=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: selectP2p +** +** Description: Select the preferred P2P technology if there is a choice. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::selectP2p() +{ + static const char fn [] = "NfcTag::selectP2p"; + UINT8 rfDiscoveryId = 0; + + for (int i = 0; i < mNumTechList; i++) + { + //if remote device does not support P2P, just skip it + if (mTechLibNfcTypes[i] != NFA_PROTOCOL_NFC_DEP) + continue; + + //if remote device supports tech F; + //tech F is preferred because it is faster than tech A + if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_F) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_F_ACTIVE) ) + { + rfDiscoveryId = mTechHandles[i]; + break; //no need to search further + } + else if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) ) + { + //only choose tech A if tech F is unavailable + if (rfDiscoveryId == 0) + rfDiscoveryId = mTechHandles[i]; + } + } + + if (rfDiscoveryId > 0) + { + ALOGD ("%s: select P2P; target rf discov id=0x%X", fn, rfDiscoveryId); + tNFA_STATUS stat = NFA_Select (rfDiscoveryId, NFA_PROTOCOL_NFC_DEP, NFA_INTERFACE_NFC_DEP); + if (stat != NFA_STATUS_OK) + ALOGE ("%s: fail select P2P; error=0x%X", fn, stat); + } + else + ALOGE ("%s: cannot find P2P", fn); + resetTechnologies (); +} + + +/******************************************************************************* +** +** Function: resetTechnologies +** +** Description: Clear all data related to the technology, protocol of the tag. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::resetTechnologies () +{ + static const char fn [] = "NfcTag::resetTechnologies"; + ALOGD ("%s", fn); + mNumTechList = 0; + memset (mTechList, 0, sizeof(mTechList)); + memset (mTechHandles, 0, sizeof(mTechHandles)); + memset (mTechLibNfcTypes, 0, sizeof(mTechLibNfcTypes)); + memset (mTechParams, 0, sizeof(mTechParams)); +} + + +/******************************************************************************* +** +** Function: selectFirstTag +** +** Description: When multiple tags are discovered, just select the first one to activate. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::selectFirstTag () +{ + static const char fn [] = "NfcTag::selectFirstTag"; + ALOGD ("%s: nfa target h=0x%X; protocol=0x%X", + fn, mTechHandles [0], mTechLibNfcTypes [0]); + tNFA_INTF_TYPE rf_intf = NFA_INTERFACE_FRAME; + + if (mTechLibNfcTypes [0] == NFA_PROTOCOL_ISO_DEP) + { + rf_intf = NFA_INTERFACE_ISO_DEP; + } + else if (mTechLibNfcTypes [0] == NFA_PROTOCOL_NFC_DEP) + rf_intf = NFA_INTERFACE_NFC_DEP; + else + rf_intf = NFA_INTERFACE_FRAME; + + tNFA_STATUS stat = NFA_Select (mTechHandles [0], mTechLibNfcTypes [0], rf_intf); + if (stat != NFA_STATUS_OK) + ALOGE ("%s: fail select; error=0x%X", fn, stat); +} + + +/******************************************************************************* +** +** Function: getT1tMaxMessageSize +** +** Description: Get the maximum size (octet) that a T1T can store. +** +** Returns: Maximum size in octets. +** +*******************************************************************************/ +int NfcTag::getT1tMaxMessageSize () +{ + static const char fn [] = "NfcTag::getT1tMaxMessageSize"; + + if (mProtocol != NFC_PROTOCOL_T1T) + { + ALOGE ("%s: wrong protocol %u", fn, mProtocol); + return 0; + } + return mtT1tMaxMessageSize; +} + + +/******************************************************************************* +** +** Function: calculateT1tMaxMessageSize +** +** Description: Calculate type-1 tag's max message size based on header ROM bytes. +** activate: reference to activation data. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::calculateT1tMaxMessageSize (tNFA_ACTIVATED& activate) +{ + static const char fn [] = "NfcTag::calculateT1tMaxMessageSize"; + + //make sure the tag is type-1 + if (activate.activate_ntf.protocol != NFC_PROTOCOL_T1T) + { + mtT1tMaxMessageSize = 0; + return; + } + + //examine the first byte of header ROM bytes + switch (activate.params.t1t.hr[0]) + { + case RW_T1T_IS_TOPAZ96: + mtT1tMaxMessageSize = 90; + break; + case RW_T1T_IS_TOPAZ512: + mtT1tMaxMessageSize = 462; + break; + default: + ALOGE ("%s: unknown T1T HR0=%u", fn, activate.params.t1t.hr[0]); + mtT1tMaxMessageSize = 0; + break; + } +} + + +/******************************************************************************* +** +** Function: isMifareUltralight +** +** Description: Whether the currently activated tag is Mifare Ultralight. +** +** Returns: True if tag is Mifare Ultralight. +** +*******************************************************************************/ +bool NfcTag::isMifareUltralight () +{ + static const char fn [] = "NfcTag::isMifareUltralight"; + bool retval = false; + + for (int i =0; i < mNumTechList; i++) + { + if ( (mTechParams[i].mode == NFC_DISCOVERY_TYPE_POLL_A) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_A) || + (mTechParams[i].mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ) + { + //see NFC Digital Protocol, section 4.6.3 (SENS_RES); section 4.8.2 (SEL_RES). + //see Mifare Type Identification Procedure, section 5.1 (ATQA), 5.2 (SAK). + if ( (mTechParams[i].param.pa.sens_res[0] == 0x44) && + (mTechParams[i].param.pa.sens_res[1] == 0) ) + { + // SyncEventGuard g (mReadCompleteEvent); + // mReadCompletedStatus = NFA_STATUS_BUSY; + // ALOGD ("%s: read block 0x10", fn); + // tNFA_STATUS stat = NFA_RwT2tRead (0x10); + // if (stat == NFA_STATUS_OK) + // mReadCompleteEvent.wait (); + // + // //if read-completion status is failure, then the tag is + // //definitely Mifare Ultralight; + // //if read-completion status is OK, then the tag is + // //definitely Mifare Ultralight C; + // retval = (mReadCompletedStatus == NFA_STATUS_FAILED); + retval = true; + } + break; + } + } + ALOGD ("%s: return=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: isT2tNackResponse +** +** Description: Whether the response is a T2T NACK response. +** See NFC Digital Protocol Technical Specification (2010-11-17). +** Chapter 9 (Type 2 Tag Platform), section 9.6 (READ). +** response: buffer contains T2T response. +** responseLen: length of the response. +** +** Returns: True if the response is NACK +** +*******************************************************************************/ +bool NfcTag::isT2tNackResponse (const UINT8* response, UINT32 responseLen) +{ + static const char fn [] = "NfcTag::isT2tNackResponse"; + bool isNack = false; + + if (responseLen == 1) + { + if (response[0] == 0xA) + isNack = false; //an ACK response, so definitely not a NACK + else + isNack = true; //assume every value is a NACK + } + ALOGD ("%s: return %u", fn, isNack); + return isNack; +} + + +/******************************************************************************* +** +** Function: isNdefDetectionTimedOut +** +** Description: Whether NDEF-detection algorithm timed out. +** +** Returns: True if NDEF-detection algorithm timed out. +** +*******************************************************************************/ +bool NfcTag::isNdefDetectionTimedOut () +{ + return mNdefDetectionTimedOut; +} + + +/******************************************************************************* +** +** Function: connectionEventHandler +** +** Description: Handle connection-related events. +** event: event code. +** data: pointer to event data. +** +** Returns: None +** +*******************************************************************************/ +void NfcTag::connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* data) +{ + static const char fn [] = "NfcTag::connectionEventHandler"; + + switch (event) + { + case NFA_DISC_RESULT_EVT: + { + tNFA_DISC_RESULT& disc_result = data->disc_result; + if (disc_result.status == NFA_STATUS_OK) + { + discoverTechnologies (disc_result); + } + } + break; + + case NFA_ACTIVATED_EVT: + // Only do tag detection if we are polling and it is not 'EE Direct RF' activation + // (which may happen when we are activated as a tag). + if (data->activated.activate_ntf.rf_tech_param.mode < NCI_DISCOVERY_TYPE_LISTEN_A + && data->activated.activate_ntf.intf_param.type != NFC_INTERFACE_EE_DIRECT_RF) + { + tNFA_ACTIVATED& activated = data->activated; + if (IsSameKovio(activated)) + break; + mProtocol = activated.activate_ntf.protocol; + calculateT1tMaxMessageSize (activated); + discoverTechnologies (activated); + createNativeNfcTag (activated); + } + break; + + case NFA_DEACTIVATED_EVT: + mProtocol = NFC_PROTOCOL_UNKNOWN; + resetTechnologies (); + break; + + case NFA_READ_CPLT_EVT: + { + SyncEventGuard g (mReadCompleteEvent); + mReadCompletedStatus = data->status; + mReadCompleteEvent.notifyOne (); + } + break; + + case NFA_NDEF_DETECT_EVT: + { + tNFA_NDEF_DETECT& ndef_detect = data->ndef_detect; + mNdefDetectionTimedOut = ndef_detect.status == NFA_STATUS_TIMEOUT; + if (mNdefDetectionTimedOut) + ALOGE ("%s: NDEF detection timed out", fn); + } + } +} + diff --git a/nci/jni/NfcTag.h b/nci/jni/NfcTag.h new file mode 100755 index 0000000..7fa56ee --- /dev/null +++ b/nci/jni/NfcTag.h @@ -0,0 +1,419 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Tag-reading, tag-writing operations. + */ + +#pragma once +#include "SyncEvent.h" +#include "NfcJniUtil.h" +extern "C" +{ + #include "nfa_rw_api.h" +} + + +class NfcTag +{ +public: + enum ActivationState {Idle, Sleep, Active}; + static const int MAX_NUM_TECHNOLOGY = 10; //max number of technologies supported by one or more tags + int mTechList [MAX_NUM_TECHNOLOGY]; //array of NFC technologies according to NFC service + int mTechHandles [MAX_NUM_TECHNOLOGY]; //array of tag handles according to NFC service + int mTechLibNfcTypes [MAX_NUM_TECHNOLOGY]; //array of detailed tag types according to NFC service + int mNumTechList; //current number of NFC technologies in the list + + /******************************************************************************* + ** + ** Function: NfcTag + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + NfcTag (); + + + /******************************************************************************* + ** + ** Function: getInstance + ** + ** Description: Get a reference to the singleton NfcTag object. + ** + ** Returns: Reference to NfcTag object. + ** + *******************************************************************************/ + static NfcTag& getInstance (); + + + /******************************************************************************* + ** + ** Function: initialize + ** + ** Description: Reset member variables. + ** native: Native data. + ** Returns: None + ** + *******************************************************************************/ + void initialize (nfc_jni_native_data* native); + + + /******************************************************************************* + ** + ** Function: abort + ** + ** Description: Unblock all operations. + ** + ** Returns: None + ** + *******************************************************************************/ + void abort (); + + + /******************************************************************************* + ** + ** Function: connectionEventHandler + ** + ** Description: Handle connection-related events. + ** event: event code. + ** data: pointer to event data. + ** + ** Returns: None + ** + *******************************************************************************/ + void connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* data); + + + /******************************************************************************* + ** + ** Function: getActivationState + ** + ** Description: What is the current state: Idle, Sleep, or Activated. + ** + ** Returns: Idle, Sleep, or Activated. + ** + *******************************************************************************/ + ActivationState getActivationState (); + + + /******************************************************************************* + ** + ** Function: setDeactivationState + ** + ** Description: Set the current state: Idle or Sleep. + ** deactivated: state of deactivation. + ** + ** Returns: None. + ** + *******************************************************************************/ + void setDeactivationState (tNFA_DEACTIVATED& deactivated); + + + /******************************************************************************* + ** + ** Function: setActivationState + ** + ** Description: Set the current state to Active. + ** + ** Returns: None. + ** + *******************************************************************************/ + void setActivationState (); + + /******************************************************************************* + ** + ** Function: getProtocol + ** + ** Description: Get the protocol of the current tag. + ** + ** Returns: Protocol number. + ** + *******************************************************************************/ + tNFC_PROTOCOL getProtocol (); + + + /******************************************************************************* + ** + ** Function: isP2pDiscovered + ** + ** Description: Does the peer support P2P? + ** + ** Returns: True if the peer supports P2P. + ** + *******************************************************************************/ + bool isP2pDiscovered (); + + + /******************************************************************************* + ** + ** Function: selectP2p + ** + ** Description: Select the preferred P2P technology if there is a choice. + ** + ** Returns: None + ** + *******************************************************************************/ + void selectP2p (); + + + /******************************************************************************* + ** + ** Function: selectFirstTag + ** + ** Description: When multiple tags are discovered, just select the first one to activate. + ** + ** Returns: None + ** + *******************************************************************************/ + void selectFirstTag (); + + + /******************************************************************************* + ** + ** Function: getT1tMaxMessageSize + ** + ** Description: Get the maximum size (octet) that a T1T can store. + ** + ** Returns: Maximum size in octets. + ** + *******************************************************************************/ + int getT1tMaxMessageSize (); + + + /******************************************************************************* + ** + ** Function: isMifareUltralight + ** + ** Description: Whether the currently activated tag is Mifare Ultralight. + ** + ** Returns: True if tag is Mifare Ultralight. + ** + *******************************************************************************/ + bool isMifareUltralight (); + + + /******************************************************************************* + ** + ** Function: isT2tNackResponse + ** + ** Description: Whether the response is a T2T NACK response. + ** See NFC Digital Protocol Technical Specification (2010-11-17). + ** Chapter 9 (Type 2 Tag Platform), section 9.6 (READ). + ** response: buffer contains T2T response. + ** responseLen: length of the response. + ** + ** Returns: True if the response is NACK + ** + *******************************************************************************/ + bool isT2tNackResponse (const UINT8* response, UINT32 responseLen); + + /******************************************************************************* + ** + ** Function: isNdefDetectionTimedOut + ** + ** Description: Whether NDEF-detection algorithm has timed out. + ** + ** Returns: True if NDEF-detection algorithm timed out. + ** + *******************************************************************************/ + bool isNdefDetectionTimedOut (); + +private: + nfc_jni_native_data* mNativeData; + ActivationState mActivationState; + tNFC_PROTOCOL mProtocol; + int mtT1tMaxMessageSize; //T1T max NDEF message size + tNFA_STATUS mReadCompletedStatus; + int mLastKovioUidLen; // len of uid of last Kovio tag activated + bool mNdefDetectionTimedOut; // whether NDEF detection algorithm timed out + tNFC_RF_TECH_PARAMS mTechParams [MAX_NUM_TECHNOLOGY]; //array of technology parameters + SyncEvent mReadCompleteEvent; + struct timespec mLastKovioTime; // time of last Kovio tag activation + UINT8 mLastKovioUid[NFC_KOVIO_MAX_LEN]; // uid of last Kovio tag activated + + + /******************************************************************************* + ** + ** Function: IsSameKovio + ** + ** Description: Checks if tag activate is the same (UID) Kovio tag previously + ** activated. This is needed due to a problem with some Kovio + ** tags re-activating multiple times. + ** activationData: data from activation. + ** + ** Returns: true if the activation is from the same tag previously + ** activated, false otherwise + ** + *******************************************************************************/ + bool IsSameKovio(tNFA_ACTIVATED& activationData); + + /******************************************************************************* + ** + ** Function: discoverTechnologies + ** + ** Description: Discover the technologies that NFC service needs by interpreting + ** the data strucutures from the stack. + ** activationData: data from activation. + ** + ** Returns: None + ** + *******************************************************************************/ + void discoverTechnologies (tNFA_ACTIVATED& activationData); + + + /******************************************************************************* + ** + ** Function: discoverTechnologies + ** + ** Description: Discover the technologies that NFC service needs by interpreting + ** the data strucutures from the stack. + ** discoveryData: data from discovery events(s). + ** + ** Returns: None + ** + *******************************************************************************/ + void discoverTechnologies (tNFA_DISC_RESULT& discoveryData); + + + /******************************************************************************* + ** + ** Function: createNativeNfcTag + ** + ** Description: Create a brand new Java NativeNfcTag object; + ** fill the objects's member variables with data; + ** notify NFC service; + ** activationData: data from activation. + ** + ** Returns: None + ** + *******************************************************************************/ + void createNativeNfcTag (tNFA_ACTIVATED& activationData); + + + /******************************************************************************* + ** + ** Function: fillNativeNfcTagMembers1 + ** + ** Description: Fill NativeNfcTag's members: mProtocols, mTechList, mTechHandles, mTechLibNfcTypes. + ** e: JVM environment. + ** tag_cls: Java NativeNfcTag class. + ** tag: Java NativeNfcTag object. + ** + ** Returns: None + ** + *******************************************************************************/ + void fillNativeNfcTagMembers1 (JNIEnv* e, jclass tag_cls, jobject tag); + + + /******************************************************************************* + ** + ** Function: fillNativeNfcTagMembers2 + ** + ** Description: Fill NativeNfcTag's members: mConnectedTechIndex or mConnectedTechnology. + ** The original Google's implementation is in set_target_pollBytes( + ** in com_android_nfc_NativeNfcTag.cpp; + ** e: JVM environment. + ** tag_cls: Java NativeNfcTag class. + ** tag: Java NativeNfcTag object. + ** activationData: data from activation. + ** + ** Returns: None + ** + *******************************************************************************/ + void fillNativeNfcTagMembers2 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData); + + + /******************************************************************************* + ** + ** Function: fillNativeNfcTagMembers3 + ** + ** Description: Fill NativeNfcTag's members: mTechPollBytes. + ** The original Google's implementation is in set_target_pollBytes( + ** in com_android_nfc_NativeNfcTag.cpp; + ** e: JVM environment. + ** tag_cls: Java NativeNfcTag class. + ** tag: Java NativeNfcTag object. + ** activationData: data from activation. + ** + ** Returns: None + ** + *******************************************************************************/ + void fillNativeNfcTagMembers3 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData); + + + /******************************************************************************* + ** + ** Function: fillNativeNfcTagMembers4 + ** + ** Description: Fill NativeNfcTag's members: mTechActBytes. + ** The original Google's implementation is in set_target_activationBytes() + ** in com_android_nfc_NativeNfcTag.cpp; + ** e: JVM environment. + ** tag_cls: Java NativeNfcTag class. + ** tag: Java NativeNfcTag object. + ** activationData: data from activation. + ** + ** Returns: None + ** + *******************************************************************************/ + void fillNativeNfcTagMembers4 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData); + + + /******************************************************************************* + ** + ** Function: fillNativeNfcTagMembers5 + ** + ** Description: Fill NativeNfcTag's members: mUid. + ** The original Google's implementation is in nfc_jni_Discovery_notification_callback() + ** in com_android_nfc_NativeNfcManager.cpp; + ** e: JVM environment. + ** tag_cls: Java NativeNfcTag class. + ** tag: Java NativeNfcTag object. + ** activationData: data from activation. + ** + ** Returns: None + ** + *******************************************************************************/ + void fillNativeNfcTagMembers5 (JNIEnv* e, jclass tag_cls, jobject tag, tNFA_ACTIVATED& activationData); + + + /******************************************************************************* + ** + ** Function: resetTechnologies + ** + ** Description: Clear all data related to the technology, protocol of the tag. + ** + ** Returns: None + ** + *******************************************************************************/ + void resetTechnologies (); + + + /******************************************************************************* + ** + ** Function: calculateT1tMaxMessageSize + ** + ** Description: Calculate type-1 tag's max message size based on header ROM bytes. + ** activate: reference to activation data. + ** + ** Returns: None + ** + *******************************************************************************/ + void calculateT1tMaxMessageSize (tNFA_ACTIVATED& activate); +}; + diff --git a/nci/jni/PeerToPeer.cpp b/nci/jni/PeerToPeer.cpp new file mode 100644 index 0000000..7994e2a --- /dev/null +++ b/nci/jni/PeerToPeer.cpp @@ -0,0 +1,1840 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Communicate with a peer using NFC-DEP, LLCP, SNEP. + */ +#include "OverrideLog.h" +#include "PeerToPeer.h" +#include "NfcJniUtil.h" +#include "llcp_defs.h" +#include "config.h" +#include "JavaClassConstants.h" + +using namespace android; + +namespace android +{ + extern void nativeNfcTag_registerNdefTypeHandler (); + extern void nativeNfcTag_deregisterNdefTypeHandler (); +} + + +PeerToPeer PeerToPeer::sP2p; +const std::string P2pServer::sSnepServiceName ("urn:nfc:sn:snep"); + + +/******************************************************************************* +** +** Function: PeerToPeer +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +PeerToPeer::PeerToPeer () +: mRemoteWKS (0), + mIsP2pListening (false), + mP2pListenTechMask (NFA_TECHNOLOGY_MASK_A + | NFA_TECHNOLOGY_MASK_F + | NFA_TECHNOLOGY_MASK_A_ACTIVE + | NFA_TECHNOLOGY_MASK_F_ACTIVE), + mNextJniHandle (1) +{ + unsigned long num = 0; + memset (mServers, 0, sizeof(mServers)); + memset (mClients, 0, sizeof(mClients)); +} + + +/******************************************************************************* +** +** Function: ~PeerToPeer +** +** Description: Free all resources. +** +** Returns: None +** +*******************************************************************************/ +PeerToPeer::~PeerToPeer () +{ +} + + +/******************************************************************************* +** +** Function: getInstance +** +** Description: Get the singleton PeerToPeer object. +** +** Returns: Singleton PeerToPeer object. +** +*******************************************************************************/ +PeerToPeer& PeerToPeer::getInstance () +{ + return sP2p; +} + + +/******************************************************************************* +** +** Function: initialize +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::initialize () +{ + ALOGD ("PeerToPeer::initialize"); + unsigned long num = 0; + + if (GetNumValue ("P2P_LISTEN_TECH_MASK", &num, sizeof (num))) + mP2pListenTechMask = num; +} + + +/******************************************************************************* +** +** Function: findServerLocked +** +** Description: Find a PeerToPeer object by connection handle. +** Assumes mMutex is already held +** nfaP2pServerHandle: Connectin handle. +** +** Returns: PeerToPeer object. +** +*******************************************************************************/ +sp PeerToPeer::findServerLocked (tNFA_HANDLE nfaP2pServerHandle) +{ + for (int i = 0; i < sMax; i++) + { + if ( (mServers[i] != NULL) + && (mServers[i]->mNfaP2pServerHandle == nfaP2pServerHandle) ) + { + return (mServers [i]); + } + } + + // If here, not found + return NULL; +} + + +/******************************************************************************* +** +** Function: findServerLocked +** +** Description: Find a PeerToPeer object by connection handle. +** Assumes mMutex is already held +** serviceName: service name. +** +** Returns: PeerToPeer object. +** +*******************************************************************************/ +sp PeerToPeer::findServerLocked (tJNI_HANDLE jniHandle) +{ + for (int i = 0; i < sMax; i++) + { + if ( (mServers[i] != NULL) + && (mServers[i]->mJniHandle == jniHandle) ) + { + return (mServers [i]); + } + } + + // If here, not found + return NULL; +} + + +/******************************************************************************* +** +** Function: findServerLocked +** +** Description: Find a PeerToPeer object by service name +** Assumes mMutex is already heldf +** serviceName: service name. +** +** Returns: PeerToPeer object. +** +*******************************************************************************/ +sp PeerToPeer::findServerLocked (const char *serviceName) +{ + for (int i = 0; i < sMax; i++) + { + if ( (mServers[i] != NULL) && (mServers[i]->mServiceName.compare(serviceName) == 0) ) + return (mServers [i]); + } + + // If here, not found + return NULL; +} + + +/******************************************************************************* +** +** Function: registerServer +** +** Description: Let a server start listening for peer's connection request. +** jniHandle: Connection handle. +** serviceName: Server's service name. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::registerServer (tJNI_HANDLE jniHandle, const char *serviceName) +{ + static const char fn [] = "PeerToPeer::registerServer"; + ALOGD ("%s: enter; service name: %s JNI handle: %u", fn, serviceName, jniHandle); + tNFA_STATUS stat = NFA_STATUS_OK; + sp pSrv = NULL; + UINT8 serverSap = NFA_P2P_ANY_SAP; + + mMutex.lock(); + // Check if already registered + if ((pSrv = findServerLocked(serviceName)) != NULL) + { + ALOGD ("%s: service name=%s already registered, handle: 0x%04x", fn, serviceName, pSrv->mNfaP2pServerHandle); + + // Update JNI handle + pSrv->mJniHandle = jniHandle; + mMutex.unlock(); + return (true); + } + + for (int ii = 0; ii < sMax; ii++) + { + if (mServers[ii] == NULL) + { + pSrv = mServers[ii] = new P2pServer(jniHandle, serviceName); + + ALOGD ("%s: added new p2p server index: %d handle: %u name: %s", fn, ii, jniHandle, serviceName); + break; + } + } + mMutex.unlock(); + + if (pSrv == NULL) + { + ALOGE ("%s: service name=%s no free entry", fn, serviceName); + return (false); + } + + if (pSrv->registerWithStack()) { + ALOGD ("%s: got new p2p server h=0x%X", fn, pSrv->mNfaP2pServerHandle); + return (true); + } else { + ALOGE ("%s: invalid server handle", fn); + removeServer (jniHandle); + return (false); + } +} + + +/******************************************************************************* +** +** Function: removeServer +** +** Description: Free resources related to a server. +** jniHandle: Connection handle. +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::removeServer (tJNI_HANDLE jniHandle) +{ + static const char fn [] = "PeerToPeer::removeServer"; + + AutoMutex mutex(mMutex); + + for (int i = 0; i < sMax; i++) + { + if ( (mServers[i] != NULL) && (mServers[i]->mJniHandle == jniHandle) ) + { + ALOGD ("%s: server jni_handle: %u; nfa_handle: 0x%04x; name: %s; index=%d", + fn, jniHandle, mServers[i]->mNfaP2pServerHandle, mServers[i]->mServiceName.c_str(), i); + + mServers [i] = NULL; + return; + } + } + ALOGE ("%s: unknown server jni handle: %u", fn, jniHandle); +} + + +/******************************************************************************* +** +** Function: llcpActivatedHandler +** +** Description: Receive LLLCP-activated event from stack. +** nat: JVM-related data. +** activated: Event data. +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::llcpActivatedHandler (nfc_jni_native_data* nat, tNFA_LLCP_ACTIVATED& activated) +{ + static const char fn [] = "PeerToPeer::llcpActivatedHandler"; + ALOGD ("%s: enter", fn); + JNIEnv* e = NULL; + jclass tag_cls = NULL; + jobject tag = NULL; + jmethodID ctor = 0; + jfieldID f = 0; + + //no longer need to receive NDEF message from a tag + android::nativeNfcTag_deregisterNdefTypeHandler (); + + mRemoteWKS = activated.remote_wks; + + nat->vm->AttachCurrentThread (&e, NULL); + if (e == NULL) + { + ALOGE ("%s: jni env is null", fn); + return; + } + + ALOGD ("%s: get object class", fn); + tag_cls = e->GetObjectClass (nat->cached_P2pDevice); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail get p2p device", fn); + goto TheEnd; + } + + ALOGD ("%s: instantiate", fn); + /* New target instance */ + ctor = e->GetMethodID (tag_cls, "", "()V"); + tag = e->NewObject (tag_cls, ctor); + + /* Set P2P Target mode */ + f = e->GetFieldID (tag_cls, "mMode", "I"); + + if (activated.is_initiator == TRUE) + { + ALOGD ("%s: p2p initiator", fn); + e->SetIntField (tag, f, (jint) MODE_P2P_INITIATOR); + } + else + { + ALOGD ("%s: p2p target", fn); + e->SetIntField (tag, f, (jint) MODE_P2P_TARGET); + } + + /* Set tag handle */ + f = e->GetFieldID (tag_cls, "mHandle", "I"); + e->SetIntField (tag, f, (jint) 0x1234); // ?? This handle is not used for anything + + if (nat->tag != NULL) + { + e->DeleteGlobalRef (nat->tag); + } + nat->tag = e->NewGlobalRef (tag); + + ALOGD ("%s: notify nfc service", fn); + + /* Notify manager that new a P2P device was found */ + e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyLlcpLinkActivation, tag); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail notify", fn); + } + + e->DeleteLocalRef (tag); + +TheEnd: + nat->vm->DetachCurrentThread (); + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: llcpDeactivatedHandler +** +** Description: Receive LLLCP-deactivated event from stack. +** nat: JVM-related data. +** deactivated: Event data. +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::llcpDeactivatedHandler (nfc_jni_native_data* nat, tNFA_LLCP_DEACTIVATED& deactivated) +{ + static const char fn [] = "PeerToPeer::llcpDeactivatedHandler"; + ALOGD ("%s: enter", fn); + JNIEnv* e = NULL; + + nat->vm->AttachCurrentThread (&e, NULL); + if (e == NULL) + { + ALOGE ("%s: jni env is null", fn); + return; + } + + ALOGD ("%s: notify nfc service", fn); + /* Notify manager that the LLCP is lost or deactivated */ + e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyLlcpLinkDeactivated, nat->tag); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail notify", fn); + } + + nat->vm->DetachCurrentThread (); + + //let the tag-reading code handle NDEF data event + android::nativeNfcTag_registerNdefTypeHandler (); + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: accept +** +** Description: Accept a peer's request to connect. +** serverJniHandle: Server's handle. +** connJniHandle: Connection handle. +** maxInfoUnit: Maximum information unit. +** recvWindow: Receive window size. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::accept (tJNI_HANDLE serverJniHandle, tJNI_HANDLE connJniHandle, int maxInfoUnit, int recvWindow) +{ + static const char fn [] = "PeerToPeer::accept"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + sp *pConn = NULL; + bool stat = false; + int ii = 0; + sp pSrv = NULL; + + ALOGD ("%s: enter; server jni handle: %u; conn jni handle: %u; maxInfoUnit: %d; recvWindow: %d", fn, + serverJniHandle, connJniHandle, maxInfoUnit, recvWindow); + + mMutex.lock(); + if ((pSrv = findServerLocked (serverJniHandle)) == NULL) + { + ALOGE ("%s: unknown server jni handle: %u", fn, serverJniHandle); + mMutex.unlock(); + return (false); + } + mMutex.unlock(); + + return pSrv->accept(serverJniHandle, connJniHandle, maxInfoUnit, recvWindow); +} + + +/******************************************************************************* +** +** Function: deregisterServer +** +** Description: Stop a P2pServer from listening for peer. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::deregisterServer (tJNI_HANDLE jniHandle) +{ + static const char fn [] = "PeerToPeer::deregisterServer"; + ALOGD ("%s: enter; JNI handle: %u", fn, jniHandle); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + sp pSrv = NULL; + + mMutex.lock(); + if ((pSrv = findServerLocked (jniHandle)) == NULL) + { + ALOGE ("%s: unknown service handle: %u", fn, jniHandle); + mMutex.unlock(); + return (false); + } + mMutex.unlock(); + + { + // Server does not call NFA_P2pDisconnect(), so unblock the accept() + SyncEventGuard guard (pSrv->mConnRequestEvent); + pSrv->mConnRequestEvent.notifyOne(); + } + + nfaStat = NFA_P2pDeregister (pSrv->mNfaP2pServerHandle); + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: deregister error=0x%X", fn, nfaStat); + } + + removeServer (jniHandle); + + ALOGD ("%s: exit", fn); + return true; +} + + +/******************************************************************************* +** +** Function: createClient +** +** Description: Create a P2pClient object for a new out-bound connection. +** jniHandle: Connection handle. +** miu: Maximum information unit. +** rw: Receive window size. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::createClient (tJNI_HANDLE jniHandle, UINT16 miu, UINT8 rw) +{ + static const char fn [] = "PeerToPeer::createClient"; + int i = 0; + ALOGD ("%s: enter: jni h: %u miu: %u rw: %u", fn, jniHandle, miu, rw); + + mMutex.lock(); + sp client = NULL; + for (i = 0; i < sMax; i++) + { + if (mClients[i] == NULL) + { + mClients [i] = client = new P2pClient(); + + mClients [i]->mClientConn->mJniHandle = jniHandle; + mClients [i]->mClientConn->mMaxInfoUnit = miu; + mClients [i]->mClientConn->mRecvWindow = rw; + break; + } + } + mMutex.unlock(); + + if (client == NULL) + { + ALOGE ("%s: fail", fn); + return (false); + } + + ALOGD ("%s: pClient: 0x%p assigned for client jniHandle: %u", fn, client.get(), jniHandle); + + { + SyncEventGuard guard (mClients[i]->mRegisteringEvent); + NFA_P2pRegisterClient (NFA_P2P_DLINK_TYPE, nfaClientCallback); + mClients[i]->mRegisteringEvent.wait(); //wait for NFA_P2P_REG_CLIENT_EVT + } + + if (mClients[i]->mNfaP2pClientHandle != NFA_HANDLE_INVALID) + { + ALOGD ("%s: exit; new client jniHandle: %u NFA Handle: 0x%04x", fn, jniHandle, client->mClientConn->mNfaConnHandle); + return (true); + } + else + { + ALOGE ("%s: FAILED; new client jniHandle: %u NFA Handle: 0x%04x", fn, jniHandle, client->mClientConn->mNfaConnHandle); + removeConn (jniHandle); + return (false); + } +} + + +/******************************************************************************* +** +** Function: removeConn +** +** Description: Free resources related to a connection. +** jniHandle: Connection handle. +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::removeConn(tJNI_HANDLE jniHandle) +{ + static const char fn[] = "PeerToPeer::removeConn"; + int ii = 0, jj = 0; + + AutoMutex mutex(mMutex); + // If the connection is a for a client, delete the client itself + for (ii = 0; ii < sMax; ii++) + { + if ((mClients[ii] != NULL) && (mClients[ii]->mClientConn->mJniHandle == jniHandle)) + { + if (mClients[ii]->mNfaP2pClientHandle != NFA_HANDLE_INVALID) + NFA_P2pDeregister (mClients[ii]->mNfaP2pClientHandle); + + mClients[ii] = NULL; + ALOGD ("%s: deleted client handle: %u index: %u", fn, jniHandle, ii); + return; + } + } + + // If the connection is for a server, just delete the connection + for (ii = 0; ii < sMax; ii++) + { + if (mServers[ii] != NULL) + { + if (mServers[ii]->removeServerConnection(jniHandle)) { + return; + } + } + } + + ALOGE ("%s: could not find handle: %u", fn, jniHandle); +} + + +/******************************************************************************* +** +** Function: connectConnOriented +** +** Description: Estabish a connection-oriented connection to a peer. +** jniHandle: Connection handle. +** serviceName: Peer's service name. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, const char* serviceName) +{ + static const char fn [] = "PeerToPeer::connectConnOriented"; + ALOGD ("%s: enter; h: %u service name=%s", fn, jniHandle, serviceName); + bool stat = createDataLinkConn (jniHandle, serviceName, 0); + ALOGD ("%s: exit; h: %u stat: %u", fn, jniHandle, stat); + return stat; +} + + +/******************************************************************************* +** +** Function: connectConnOriented +** +** Description: Estabish a connection-oriented connection to a peer. +** jniHandle: Connection handle. +** destinationSap: Peer's service access point. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, UINT8 destinationSap) +{ + static const char fn [] = "PeerToPeer::connectConnOriented"; + ALOGD ("%s: enter; h: %u dest sap: 0x%X", fn, jniHandle, destinationSap); + bool stat = createDataLinkConn (jniHandle, NULL, destinationSap); + ALOGD ("%s: exit; h: %u stat: %u", fn, jniHandle, stat); + return stat; +} + + +/******************************************************************************* +** +** Function: createDataLinkConn +** +** Description: Estabish a connection-oriented connection to a peer. +** jniHandle: Connection handle. +** serviceName: Peer's service name. +** destinationSap: Peer's service access point. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceName, UINT8 destinationSap) +{ + static const char fn [] = "PeerToPeer::createDataLinkConn"; + ALOGD ("%s: enter", fn); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + sp pClient = NULL; + + if ((pClient = findClient (jniHandle)) == NULL) + { + ALOGE ("%s: can't find client, JNI handle: %u", fn, jniHandle); + return (false); + } + + { + SyncEventGuard guard (pClient->mConnectingEvent); + pClient->mIsConnecting = true; + + if (serviceName) + nfaStat = NFA_P2pConnectByName (pClient->mNfaP2pClientHandle, + const_cast(serviceName), pClient->mClientConn->mMaxInfoUnit, + pClient->mClientConn->mRecvWindow); + else if (destinationSap) + nfaStat = NFA_P2pConnectBySap (pClient->mNfaP2pClientHandle, destinationSap, + pClient->mClientConn->mMaxInfoUnit, pClient->mClientConn->mRecvWindow); + if (nfaStat == NFA_STATUS_OK) + { + ALOGD ("%s: wait for connected event mConnectingEvent: 0x%p", fn, pClient.get()); + pClient->mConnectingEvent.wait(); + } + } + + if (nfaStat == NFA_STATUS_OK) + { + if (pClient->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID) + { + removeConn (jniHandle); + nfaStat = NFA_STATUS_FAILED; + } + else + pClient->mIsConnecting = false; + } + else + { + removeConn (jniHandle); + ALOGE ("%s: fail; error=0x%X", fn, nfaStat); + } + + ALOGD ("%s: exit", fn); + return nfaStat == NFA_STATUS_OK; +} + + +/******************************************************************************* +** +** Function: findClient +** +** Description: Find a PeerToPeer object with a client connection handle. +** nfaConnHandle: Connection handle. +** +** Returns: PeerToPeer object. +** +*******************************************************************************/ +sp PeerToPeer::findClient (tNFA_HANDLE nfaConnHandle) +{ + AutoMutex mutex(mMutex); + for (int i = 0; i < sMax; i++) + { + if ((mClients[i] != NULL) && (mClients[i]->mNfaP2pClientHandle == nfaConnHandle)) + return (mClients[i]); + } + return (NULL); +} + + +/******************************************************************************* +** +** Function: findClient +** +** Description: Find a PeerToPeer object with a client connection handle. +** jniHandle: Connection handle. +** +** Returns: PeerToPeer object. +** +*******************************************************************************/ +sp PeerToPeer::findClient (tJNI_HANDLE jniHandle) +{ + AutoMutex mutex(mMutex); + for (int i = 0; i < sMax; i++) + { + if ((mClients[i] != NULL) && (mClients[i]->mClientConn->mJniHandle == jniHandle)) + return (mClients[i]); + } + return (NULL); +} + + +/******************************************************************************* +** +** Function: findClientCon +** +** Description: Find a PeerToPeer object with a client connection handle. +** nfaConnHandle: Connection handle. +** +** Returns: PeerToPeer object. +** +*******************************************************************************/ +sp PeerToPeer::findClientCon (tNFA_HANDLE nfaConnHandle) +{ + AutoMutex mutex(mMutex); + for (int i = 0; i < sMax; i++) + { + if ((mClients[i] != NULL) && (mClients[i]->mClientConn->mNfaConnHandle == nfaConnHandle)) + return (mClients[i]); + } + return (NULL); +} + + +/******************************************************************************* +** +** Function: findConnection +** +** Description: Find a PeerToPeer object with a connection handle. +** nfaConnHandle: Connection handle. +** +** Returns: PeerToPeer object. +** +*******************************************************************************/ +sp PeerToPeer::findConnection (tNFA_HANDLE nfaConnHandle) +{ + int ii = 0, jj = 0; + + AutoMutex mutex(mMutex); + // First, look through all the client control blocks + for (ii = 0; ii < sMax; ii++) + { + if ( (mClients[ii] != NULL) + && (mClients[ii]->mClientConn->mNfaConnHandle == nfaConnHandle) ) { + return mClients[ii]->mClientConn; + } + } + + // Not found yet. Look through all the server control blocks + for (ii = 0; ii < sMax; ii++) + { + if (mServers[ii] != NULL) + { + sp conn = mServers[ii]->findServerConnection(nfaConnHandle); + if (conn != NULL) { + return conn; + } + } + } + + // Not found... + return NULL; +} + + +/******************************************************************************* +** +** Function: findConnection +** +** Description: Find a PeerToPeer object with a connection handle. +** jniHandle: Connection handle. +** +** Returns: PeerToPeer object. +** +*******************************************************************************/ +sp PeerToPeer::findConnection (tJNI_HANDLE jniHandle) +{ + int ii = 0, jj = 0; + + AutoMutex mutex(mMutex); + // First, look through all the client control blocks + for (ii = 0; ii < sMax; ii++) + { + if ( (mClients[ii] != NULL) + && (mClients[ii]->mClientConn->mJniHandle == jniHandle) ) { + return mClients[ii]->mClientConn; + } + } + + // Not found yet. Look through all the server control blocks + for (ii = 0; ii < sMax; ii++) + { + if (mServers[ii] != NULL) + { + sp conn = mServers[ii]->findServerConnection(jniHandle); + if (conn != NULL) { + return conn; + } + } + } + + // Not found... + return NULL; +} + + +/******************************************************************************* +** +** Function: send +** +** Description: Send data to peer. +** jniHandle: Handle of connection. +** buffer: Buffer of data. +** bufferLen: Length of data. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::send (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 bufferLen) +{ + static const char fn [] = "PeerToPeer::send"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + sp pConn = NULL; + + if ((pConn = findConnection (jniHandle)) == NULL) + { + ALOGE ("%s: can't find connection handle: %u", fn, jniHandle); + return (false); + } + + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: send data; jniHandle: %u nfaHandle: 0x%04X", + fn, pConn->mJniHandle, pConn->mNfaConnHandle); + + while (true) + { + SyncEventGuard guard (pConn->mCongEvent); + nfaStat = NFA_P2pSendData (pConn->mNfaConnHandle, bufferLen, buffer); + if (nfaStat == NFA_STATUS_CONGESTED) + pConn->mCongEvent.wait (); //wait for NFA_P2P_CONGEST_EVT + else + break; + + if (pConn->mNfaConnHandle == NFA_HANDLE_INVALID) //peer already disconnected + { + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: peer disconnected", fn); + return (false); + } + } + + if (nfaStat == NFA_STATUS_OK) + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit OK; JNI handle: %u NFA Handle: 0x%04x", fn, jniHandle, pConn->mNfaConnHandle); + else + ALOGE ("%s: Data not sent; JNI handle: %u NFA Handle: 0x%04x error: 0x%04x", + fn, jniHandle, pConn->mNfaConnHandle, nfaStat); + + return nfaStat == NFA_STATUS_OK; +} + + +/******************************************************************************* +** +** Function: receive +** +** Description: Receive data from peer. +** jniHandle: Handle of connection. +** buffer: Buffer to store data. +** bufferLen: Max length of buffer. +** actualLen: Actual length received. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen, UINT16& actualLen) +{ + static const char fn [] = "PeerToPeer::receive"; + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; jniHandle: %u bufferLen: %u", fn, jniHandle, bufferLen); + sp pConn = NULL; + tNFA_STATUS stat = NFA_STATUS_FAILED; + UINT32 actualDataLen2 = 0; + BOOLEAN isMoreData = TRUE; + bool retVal = false; + + if ((pConn = findConnection (jniHandle)) == NULL) + { + ALOGE ("%s: can't find connection handle: %u", fn, jniHandle); + return (false); + } + + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: jniHandle: %u nfaHandle: 0x%04X buf len=%u", fn, pConn->mJniHandle, pConn->mNfaConnHandle, bufferLen); + + while (pConn->mNfaConnHandle != NFA_HANDLE_INVALID) + { + //NFA_P2pReadData() is synchronous + stat = NFA_P2pReadData (pConn->mNfaConnHandle, bufferLen, &actualDataLen2, buffer, &isMoreData); + if ((stat == NFA_STATUS_OK) && (actualDataLen2 > 0)) //received some data + { + actualLen = (UINT16) actualDataLen2; + retVal = true; + break; + } + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: waiting for data...", fn); + { + SyncEventGuard guard (pConn->mReadEvent); + pConn->mReadEvent.wait(); + } + } //while + + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit; nfa h: 0x%X ok: %u actual len: %u", fn, pConn->mNfaConnHandle, retVal, actualLen); + return retVal; +} + + +/******************************************************************************* +** +** Function: disconnectConnOriented +** +** Description: Disconnect a connection-oriented connection with peer. +** jniHandle: Handle of connection. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PeerToPeer::disconnectConnOriented (tJNI_HANDLE jniHandle) +{ + static const char fn [] = "PeerToPeer::disconnectConnOriented"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + sp pClient = NULL; + sp pConn = NULL; + + ALOGD ("%s: enter; jni handle: %u", fn, jniHandle); + + if ((pConn = findConnection(jniHandle)) == NULL) + { + ALOGE ("%s: can't find connection handle: %u", fn, jniHandle); + return (false); + } + + // If this is a client, he may not be connected yet, so unblock him just in case + if ( ((pClient = findClient(jniHandle)) != NULL) && (pClient->mIsConnecting) ) + { + SyncEventGuard guard (pClient->mConnectingEvent); + pClient->mConnectingEvent.notifyOne(); + return (true); + } + + { + SyncEventGuard guard1 (pConn->mCongEvent); + pConn->mCongEvent.notifyOne (); //unblock send() if congested + } + { + SyncEventGuard guard2 (pConn->mReadEvent); + pConn->mReadEvent.notifyOne (); //unblock receive() + } + + if (pConn->mNfaConnHandle != NFA_HANDLE_INVALID) + { + ALOGD ("%s: try disconn nfa h=0x%04X", fn, pConn->mNfaConnHandle); + SyncEventGuard guard (pConn->mDisconnectingEvent); + nfaStat = NFA_P2pDisconnect (pConn->mNfaConnHandle, FALSE); + + if (nfaStat != NFA_STATUS_OK) + ALOGE ("%s: fail p2p disconnect", fn); + else + pConn->mDisconnectingEvent.wait(); + } + + mDisconnectMutex.lock (); + removeConn (jniHandle); + mDisconnectMutex.unlock (); + + ALOGD ("%s: exit; jni handle: %u", fn, jniHandle); + return nfaStat == NFA_STATUS_OK; +} + + +/******************************************************************************* +** +** Function: getRemoteMaxInfoUnit +** +** Description: Get peer's max information unit. +** jniHandle: Handle of the connection. +** +** Returns: Peer's max information unit. +** +*******************************************************************************/ +UINT16 PeerToPeer::getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle) +{ + static const char fn [] = "PeerToPeer::getRemoteMaxInfoUnit"; + sp pConn = NULL; + + if ((pConn = findConnection(jniHandle)) == NULL) + { + ALOGE ("%s: can't find client jniHandle: %u", fn, jniHandle); + return 0; + } + ALOGD ("%s: jniHandle: %u MIU: %u", fn, jniHandle, pConn->mRemoteMaxInfoUnit); + return (pConn->mRemoteMaxInfoUnit); +} + + +/******************************************************************************* +** +** Function: getRemoteRecvWindow +** +** Description: Get peer's receive window size. +** jniHandle: Handle of the connection. +** +** Returns: Peer's receive window size. +** +*******************************************************************************/ +UINT8 PeerToPeer::getRemoteRecvWindow (tJNI_HANDLE jniHandle) +{ + static const char fn [] = "PeerToPeer::getRemoteRecvWindow"; + ALOGD ("%s: client jni handle: %u", fn, jniHandle); + sp pConn = NULL; + + if ((pConn = findConnection(jniHandle)) == NULL) + { + ALOGE ("%s: can't find client", fn); + return 0; + } + return pConn->mRemoteRecvWindow; +} + +/******************************************************************************* +** +** Function: setP2pListenMask +** +** Description: Sets the p2p listen technology mask. +** p2pListenMask: the p2p listen mask to be set? +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::setP2pListenMask (tNFA_TECHNOLOGY_MASK p2pListenMask) { + mP2pListenTechMask = p2pListenMask; +} + +/******************************************************************************* +** +** Function: enableP2pListening +** +** Description: Start/stop polling/listening to peer that supports P2P. +** isEnable: Is enable polling/listening? +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::enableP2pListening (bool isEnable) +{ + static const char fn [] = "PeerToPeer::enableP2pListening"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + + ALOGD ("%s: enter isEnable: %u mIsP2pListening: %u", fn, isEnable, mIsP2pListening); + + // If request to enable P2P listening, and we were not already listening + if ( (isEnable == true) && (mIsP2pListening == false) && (mP2pListenTechMask != 0) ) + { + SyncEventGuard guard (mSetTechEvent); + if ((nfaStat = NFA_SetP2pListenTech (mP2pListenTechMask)) == NFA_STATUS_OK) + { + mSetTechEvent.wait (); + mIsP2pListening = true; + } + else + ALOGE ("%s: fail enable listen; error=0x%X", fn, nfaStat); + } + else if ( (isEnable == false) && (mIsP2pListening == true) ) + { + SyncEventGuard guard (mSetTechEvent); + // Request to disable P2P listening, check if it was enabled + if ((nfaStat = NFA_SetP2pListenTech(0)) == NFA_STATUS_OK) + { + mSetTechEvent.wait (); + mIsP2pListening = false; + } + else + ALOGE ("%s: fail disable listen; error=0x%X", fn, nfaStat); + } + ALOGD ("%s: exit; mIsP2pListening: %u", fn, mIsP2pListening); +} + + +/******************************************************************************* +** +** Function: handleNfcOnOff +** +** Description: Handle events related to turning NFC on/off by the user. +** isOn: Is NFC turning on? +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::handleNfcOnOff (bool isOn) +{ + static const char fn [] = "PeerToPeer::handleNfcOnOff"; + ALOGD ("%s: enter; is on=%u", fn, isOn); + tNFA_STATUS stat = NFA_STATUS_FAILED; + + mIsP2pListening = false; // In both cases, P2P will not be listening + + AutoMutex mutex(mMutex); + if (isOn) + { + // Start with no clients or servers + memset (mServers, 0, sizeof(mServers)); + memset (mClients, 0, sizeof(mClients)); + } + else + { + int ii = 0, jj = 0; + + // Disconnect through all the clients + for (ii = 0; ii < sMax; ii++) + { + if (mClients[ii] != NULL) + { + if (mClients[ii]->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID) + { + SyncEventGuard guard (mClients[ii]->mConnectingEvent); + mClients[ii]->mConnectingEvent.notifyOne(); + } + else + { + mClients[ii]->mClientConn->mNfaConnHandle = NFA_HANDLE_INVALID; + { + SyncEventGuard guard1 (mClients[ii]->mClientConn->mCongEvent); + mClients[ii]->mClientConn->mCongEvent.notifyOne (); //unblock send() + } + { + SyncEventGuard guard2 (mClients[ii]->mClientConn->mReadEvent); + mClients[ii]->mClientConn->mReadEvent.notifyOne (); //unblock receive() + } + } + } + } //loop + + // Now look through all the server control blocks + for (ii = 0; ii < sMax; ii++) + { + if (mServers[ii] != NULL) + { + mServers[ii]->unblockAll(); + } + } //loop + + } + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: nfaServerCallback +** +** Description: Receive LLCP-related events from the stack. +** p2pEvent: Event code. +** eventData: Event data. +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* eventData) +{ + static const char fn [] = "PeerToPeer::nfaServerCallback"; + sp pSrv = NULL; + sp pConn = NULL; + + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; event=0x%X", fn, p2pEvent); + + switch (p2pEvent) + { + case NFA_P2P_REG_SERVER_EVT: // NFA_P2pRegisterServer() has started to listen + ALOGD ("%s: NFA_P2P_REG_SERVER_EVT; handle: 0x%04x; service sap=0x%02x name: %s", fn, + eventData->reg_server.server_handle, eventData->reg_server.server_sap, eventData->reg_server.service_name); + + sP2p.mMutex.lock(); + pSrv = sP2p.findServerLocked(eventData->reg_server.service_name); + sP2p.mMutex.unlock(); + if (pSrv == NULL) + { + ALOGE ("%s: NFA_P2P_REG_SERVER_EVT for unknown service: %s", fn, eventData->reg_server.service_name); + } + else + { + SyncEventGuard guard (pSrv->mRegServerEvent); + pSrv->mNfaP2pServerHandle = eventData->reg_server.server_handle; + pSrv->mRegServerEvent.notifyOne(); //unblock registerServer() + } + break; + + case NFA_P2P_ACTIVATED_EVT: //remote device has activated + ALOGD ("%s: NFA_P2P_ACTIVATED_EVT; handle: 0x%04x", fn, eventData->activated.handle); + break; + + case NFA_P2P_DEACTIVATED_EVT: + ALOGD ("%s: NFA_P2P_DEACTIVATED_EVT; handle: 0x%04x", fn, eventData->activated.handle); + break; + + case NFA_P2P_CONN_REQ_EVT: + ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; nfa server h=0x%04x; nfa conn h=0x%04x; remote sap=0x%02x", fn, + eventData->conn_req.server_handle, eventData->conn_req.conn_handle, eventData->conn_req.remote_sap); + + sP2p.mMutex.lock(); + pSrv = sP2p.findServerLocked(eventData->conn_req.server_handle); + sP2p.mMutex.unlock(); + if (pSrv == NULL) + { + ALOGE ("%s: NFA_P2P_CONN_REQ_EVT; unknown server h", fn); + return; + } + ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u", fn, pSrv->mJniHandle); + + // Look for a connection block that is waiting (handle invalid) + if ((pConn = pSrv->findServerConnection((tNFA_HANDLE) NFA_HANDLE_INVALID)) == NULL) + { + ALOGE ("%s: NFA_P2P_CONN_REQ_EVT; server not listening", fn); + } + else + { + SyncEventGuard guard (pSrv->mConnRequestEvent); + pConn->mNfaConnHandle = eventData->conn_req.conn_handle; + pConn->mRemoteMaxInfoUnit = eventData->conn_req.remote_miu; + pConn->mRemoteRecvWindow = eventData->conn_req.remote_rw; + ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u; conn jni h=%u; notify conn req", fn, pSrv->mJniHandle, pConn->mJniHandle); + pSrv->mConnRequestEvent.notifyOne(); //unblock accept() + } + break; + + case NFA_P2P_CONNECTED_EVT: + ALOGD ("%s: NFA_P2P_CONNECTED_EVT; h=0x%x remote sap=0x%X", fn, + eventData->connected.client_handle, eventData->connected.remote_sap); + break; + + case NFA_P2P_DISC_EVT: + ALOGD ("%s: NFA_P2P_DISC_EVT; h=0x%04x; reason=0x%X", fn, eventData->disc.handle, eventData->disc.reason); + // Look for the connection block + if ((pConn = sP2p.findConnection(eventData->disc.handle)) == NULL) + { + ALOGE ("%s: NFA_P2P_DISC_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->disc.handle); + } + else + { + sP2p.mDisconnectMutex.lock (); + pConn->mNfaConnHandle = NFA_HANDLE_INVALID; + { + ALOGD ("%s: NFA_P2P_DISC_EVT; try guard disconn event", fn); + SyncEventGuard guard3 (pConn->mDisconnectingEvent); + pConn->mDisconnectingEvent.notifyOne (); + ALOGD ("%s: NFA_P2P_DISC_EVT; notified disconn event", fn); + } + { + ALOGD ("%s: NFA_P2P_DISC_EVT; try guard congest event", fn); + SyncEventGuard guard1 (pConn->mCongEvent); + pConn->mCongEvent.notifyOne (); //unblock write (if congested) + ALOGD ("%s: NFA_P2P_DISC_EVT; notified congest event", fn); + } + { + ALOGD ("%s: NFA_P2P_DISC_EVT; try guard read event", fn); + SyncEventGuard guard2 (pConn->mReadEvent); + pConn->mReadEvent.notifyOne (); //unblock receive() + ALOGD ("%s: NFA_P2P_DISC_EVT; notified read event", fn); + } + sP2p.mDisconnectMutex.unlock (); + } + break; + + case NFA_P2P_DATA_EVT: + // Look for the connection block + if ((pConn = sP2p.findConnection(eventData->data.handle)) == NULL) + { + ALOGE ("%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->data.handle); + } + else + { + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_DATA_EVT; h=0x%X; remote sap=0x%X", fn, + eventData->data.handle, eventData->data.remote_sap); + SyncEventGuard guard (pConn->mReadEvent); + pConn->mReadEvent.notifyOne(); + } + break; + + case NFA_P2P_CONGEST_EVT: + // Look for the connection block + if ((pConn = sP2p.findConnection(eventData->congest.handle)) == NULL) + { + ALOGE ("%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->congest.handle); + } + else + { + ALOGD ("%s: NFA_P2P_CONGEST_EVT; nfa handle: 0x%04x congested: %u", fn, + eventData->congest.handle, eventData->congest.is_congested); + if (eventData->congest.is_congested == FALSE) + { + SyncEventGuard guard (pConn->mCongEvent); + pConn->mCongEvent.notifyOne(); + } + } + break; + + default: + ALOGE ("%s: unknown event 0x%X ????", fn, p2pEvent); + break; + } + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: nfaClientCallback +** +** Description: Receive LLCP-related events from the stack. +** p2pEvent: Event code. +** eventData: Event data. +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* eventData) +{ + static const char fn [] = "PeerToPeer::nfaClientCallback"; + sp pConn = NULL; + sp pClient = NULL; + + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; event=%u", fn, p2pEvent); + + switch (p2pEvent) + { + case NFA_P2P_REG_CLIENT_EVT: + // Look for a client that is trying to register + if ((pClient = sP2p.findClient ((tNFA_HANDLE)NFA_HANDLE_INVALID)) == NULL) + { + ALOGE ("%s: NFA_P2P_REG_CLIENT_EVT: can't find waiting client", fn); + } + else + { + ALOGD ("%s: NFA_P2P_REG_CLIENT_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->reg_client.client_handle, pClient.get()); + + SyncEventGuard guard (pClient->mRegisteringEvent); + pClient->mNfaP2pClientHandle = eventData->reg_client.client_handle; + pClient->mRegisteringEvent.notifyOne(); + } + break; + + case NFA_P2P_ACTIVATED_EVT: + // Look for a client that is trying to register + if ((pClient = sP2p.findClient (eventData->activated.handle)) == NULL) + { + ALOGE ("%s: NFA_P2P_ACTIVATED_EVT: can't find client", fn); + } + else + { + ALOGD ("%s: NFA_P2P_ACTIVATED_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->activated.handle, pClient.get()); + } + break; + + case NFA_P2P_DEACTIVATED_EVT: + ALOGD ("%s: NFA_P2P_DEACTIVATED_EVT: conn handle: 0x%X", fn, eventData->deactivated.handle); + break; + + case NFA_P2P_CONNECTED_EVT: + // Look for the client that is trying to connect + if ((pClient = sP2p.findClient (eventData->connected.client_handle)) == NULL) + { + ALOGE ("%s: NFA_P2P_CONNECTED_EVT: can't find client: 0x%04x", fn, eventData->connected.client_handle); + } + else + { + ALOGD ("%s: NFA_P2P_CONNECTED_EVT; client_handle=0x%04x conn_handle: 0x%04x remote sap=0x%X pClient: 0x%p", fn, + eventData->connected.client_handle, eventData->connected.conn_handle, eventData->connected.remote_sap, pClient.get()); + + SyncEventGuard guard (pClient->mConnectingEvent); + pClient->mClientConn->mNfaConnHandle = eventData->connected.conn_handle; + pClient->mClientConn->mRemoteMaxInfoUnit = eventData->connected.remote_miu; + pClient->mClientConn->mRemoteRecvWindow = eventData->connected.remote_rw; + pClient->mConnectingEvent.notifyOne(); //unblock createDataLinkConn() + } + break; + + case NFA_P2P_DISC_EVT: + ALOGD ("%s: NFA_P2P_DISC_EVT; h=0x%04x; reason=0x%X", fn, eventData->disc.handle, eventData->disc.reason); + // Look for the connection block + if ((pConn = sP2p.findConnection(eventData->disc.handle)) == NULL) + { + // If no connection, may be a client that is trying to connect + if ((pClient = sP2p.findClientCon ((tNFA_HANDLE)NFA_HANDLE_INVALID)) == NULL) + { + ALOGE ("%s: NFA_P2P_DISC_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->disc.handle); + return; + } + // Unblock createDataLinkConn() + SyncEventGuard guard (pClient->mConnectingEvent); + pClient->mConnectingEvent.notifyOne(); + } + else + { + sP2p.mDisconnectMutex.lock (); + pConn->mNfaConnHandle = NFA_HANDLE_INVALID; + { + ALOGD ("%s: NFA_P2P_DISC_EVT; try guard disconn event", fn); + SyncEventGuard guard3 (pConn->mDisconnectingEvent); + pConn->mDisconnectingEvent.notifyOne (); + ALOGD ("%s: NFA_P2P_DISC_EVT; notified disconn event", fn); + } + { + ALOGD ("%s: NFA_P2P_DISC_EVT; try guard congest event", fn); + SyncEventGuard guard1 (pConn->mCongEvent); + pConn->mCongEvent.notifyOne(); //unblock write (if congested) + ALOGD ("%s: NFA_P2P_DISC_EVT; notified congest event", fn); + } + { + ALOGD ("%s: NFA_P2P_DISC_EVT; try guard read event", fn); + SyncEventGuard guard2 (pConn->mReadEvent); + pConn->mReadEvent.notifyOne(); //unblock receive() + ALOGD ("%s: NFA_P2P_DISC_EVT; notified read event", fn); + } + sP2p.mDisconnectMutex.unlock (); + } + break; + + case NFA_P2P_DATA_EVT: + // Look for the connection block + if ((pConn = sP2p.findConnection(eventData->data.handle)) == NULL) + { + ALOGE ("%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->data.handle); + } + else + { + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_DATA_EVT; h=0x%X; remote sap=0x%X", fn, + eventData->data.handle, eventData->data.remote_sap); + SyncEventGuard guard (pConn->mReadEvent); + pConn->mReadEvent.notifyOne(); + } + break; + + case NFA_P2P_CONGEST_EVT: + // Look for the connection block + if ((pConn = sP2p.findConnection(eventData->congest.handle)) == NULL) + { + ALOGE ("%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->congest.handle); + } + else + { + ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_CONGEST_EVT; nfa handle: 0x%04x congested: %u", fn, + eventData->congest.handle, eventData->congest.is_congested); + + SyncEventGuard guard (pConn->mCongEvent); + pConn->mCongEvent.notifyOne(); + } + break; + + default: + ALOGE ("%s: unknown event 0x%X ????", fn, p2pEvent); + break; + } +} + + +/******************************************************************************* +** +** Function: connectionEventHandler +** +** Description: Receive events from the stack. +** event: Event code. +** eventData: Event data. +** +** Returns: None +** +*******************************************************************************/ +void PeerToPeer::connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* eventData) +{ + switch (event) + { + case NFA_SET_P2P_LISTEN_TECH_EVT: + { + SyncEventGuard guard (mSetTechEvent); + mSetTechEvent.notifyOne(); //unblock NFA_SetP2pListenTech() + break; + } + } +} + + +/******************************************************************************* +** +** Function: getNextJniHandle +** +** Description: Get a new JNI handle. +** +** Returns: A new JNI handle. +** +*******************************************************************************/ +PeerToPeer::tJNI_HANDLE PeerToPeer::getNewJniHandle () +{ + tJNI_HANDLE newHandle = 0; + + mNewJniHandleMutex.lock (); + newHandle = mNextJniHandle++; + mNewJniHandleMutex.unlock (); + return newHandle; +} + + +///////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////// + + +/******************************************************************************* +** +** Function: P2pServer +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +P2pServer::P2pServer(PeerToPeer::tJNI_HANDLE jniHandle, const char* serviceName) +: mNfaP2pServerHandle (NFA_HANDLE_INVALID), + mJniHandle (jniHandle) +{ + mServiceName.assign (serviceName); + + memset (mServerConn, 0, sizeof(mServerConn)); +} + +bool P2pServer::registerWithStack() +{ + static const char fn [] = "P2pServer::registerWithStack"; + ALOGD ("%s: enter; service name: %s JNI handle: %u", fn, mServiceName.c_str(), mJniHandle); + tNFA_STATUS stat = NFA_STATUS_OK; + UINT8 serverSap = NFA_P2P_ANY_SAP; + + /********************** + default values for all LLCP parameters: + - Local Link MIU (LLCP_MIU) + - Option parameter (LLCP_OPT_VALUE) + - Response Waiting Time Index (LLCP_WAITING_TIME) + - Local Link Timeout (LLCP_LTO_VALUE) + - Inactivity Timeout as initiator role (LLCP_INIT_INACTIVITY_TIMEOUT) + - Inactivity Timeout as target role (LLCP_TARGET_INACTIVITY_TIMEOUT) + - Delay SYMM response (LLCP_DELAY_RESP_TIME) + - Data link connection timeout (LLCP_DATA_LINK_CONNECTION_TOUT) + - Delay timeout to send first PDU as initiator (LLCP_DELAY_TIME_TO_SEND_FIRST_PDU) + ************************/ + stat = NFA_P2pSetLLCPConfig (LLCP_MAX_MIU, + LLCP_OPT_VALUE, + LLCP_WAITING_TIME, + LLCP_LTO_VALUE, + 0, //use 0 for infinite timeout for symmetry procedure when acting as initiator + 0, //use 0 for infinite timeout for symmetry procedure when acting as target + LLCP_DELAY_RESP_TIME, + LLCP_DATA_LINK_CONNECTION_TOUT, + LLCP_DELAY_TIME_TO_SEND_FIRST_PDU); + if (stat != NFA_STATUS_OK) + ALOGE ("%s: fail set LLCP config; error=0x%X", fn, stat); + + if (sSnepServiceName.compare(mServiceName) == 0) + serverSap = LLCP_SAP_SNEP; //LLCP_SAP_SNEP == 4 + + { + SyncEventGuard guard (mRegServerEvent); + stat = NFA_P2pRegisterServer (serverSap, NFA_P2P_DLINK_TYPE, const_cast(mServiceName.c_str()), + PeerToPeer::nfaServerCallback); + if (stat != NFA_STATUS_OK) + { + ALOGE ("%s: fail register p2p server; error=0x%X", fn, stat); + return (false); + } + ALOGD ("%s: wait for listen-completion event", fn); + // Wait for NFA_P2P_REG_SERVER_EVT + mRegServerEvent.wait (); + } + + return (mNfaP2pServerHandle != NFA_HANDLE_INVALID); +} + +bool P2pServer::accept(PeerToPeer::tJNI_HANDLE serverJniHandle, PeerToPeer::tJNI_HANDLE connJniHandle, + int maxInfoUnit, int recvWindow) +{ + static const char fn [] = "P2pServer::accept"; + tNFA_STATUS nfaStat = NFA_STATUS_OK; + + sp connection = allocateConnection(connJniHandle); + if (connection == NULL) { + ALOGE ("%s: failed to allocate new server connection", fn); + return false; + } + + { + // Wait for NFA_P2P_CONN_REQ_EVT or NFA_NDEF_DATA_EVT when remote device requests connection + SyncEventGuard guard (mConnRequestEvent); + ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; wait for incoming connection", fn, + serverJniHandle, connJniHandle); + mConnRequestEvent.wait(); + ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; got incoming connection", fn, + serverJniHandle, connJniHandle, connection->mNfaConnHandle); + } + + if (connection->mNfaConnHandle == NFA_HANDLE_INVALID) + { + removeServerConnection(connJniHandle); + ALOGD ("%s: no handle assigned", fn); + return (false); + } + + ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; try accept", fn, + serverJniHandle, connJniHandle, connection->mNfaConnHandle); + nfaStat = NFA_P2pAcceptConn (connection->mNfaConnHandle, maxInfoUnit, recvWindow); + + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: fail to accept remote; error=0x%X", fn, nfaStat); + return (false); + } + + ALOGD ("%s: exit; serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X", fn, + serverJniHandle, connJniHandle, connection->mNfaConnHandle); + return (true); +} + +void P2pServer::unblockAll() +{ + AutoMutex mutex(mMutex); + for (int jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) + { + if (mServerConn[jj] != NULL) + { + mServerConn[jj]->mNfaConnHandle = NFA_HANDLE_INVALID; + { + SyncEventGuard guard1 (mServerConn[jj]->mCongEvent); + mServerConn[jj]->mCongEvent.notifyOne (); //unblock write (if congested) + } + { + SyncEventGuard guard2 (mServerConn[jj]->mReadEvent); + mServerConn[jj]->mReadEvent.notifyOne (); //unblock receive() + } + } + } +} + +sp P2pServer::allocateConnection (PeerToPeer::tJNI_HANDLE jniHandle) +{ + AutoMutex mutex(mMutex); + // First, find a free connection block to handle the connection + for (int ii = 0; ii < MAX_NFA_CONNS_PER_SERVER; ii++) + { + if (mServerConn[ii] == NULL) + { + mServerConn[ii] = new NfaConn; + mServerConn[ii]->mJniHandle = jniHandle; + return mServerConn[ii]; + } + } + + return NULL; +} + + +/******************************************************************************* +** +** Function: findServerConnection +** +** Description: Find a P2pServer that has the handle. +** nfaConnHandle: NFA connection handle. +** +** Returns: P2pServer object. +** +*******************************************************************************/ +sp P2pServer::findServerConnection (tNFA_HANDLE nfaConnHandle) +{ + int jj = 0; + + AutoMutex mutex(mMutex); + for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) + { + if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mNfaConnHandle == nfaConnHandle) ) + return (mServerConn[jj]); + } + + // If here, not found + return (NULL); +} + +/******************************************************************************* +** +** Function: findServerConnection +** +** Description: Find a P2pServer that has the handle. +** nfaConnHandle: NFA connection handle. +** +** Returns: P2pServer object. +** +*******************************************************************************/ +sp P2pServer::findServerConnection (PeerToPeer::tJNI_HANDLE jniHandle) +{ + int jj = 0; + + AutoMutex mutex(mMutex); + for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) + { + if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) ) + return (mServerConn[jj]); + } + + // If here, not found + return (NULL); +} + +/******************************************************************************* +** +** Function: removeServerConnection +** +** Description: Find a P2pServer that has the handle. +** nfaConnHandle: NFA connection handle. +** +** Returns: P2pServer object. +** +*******************************************************************************/ +bool P2pServer::removeServerConnection (PeerToPeer::tJNI_HANDLE jniHandle) +{ + int jj = 0; + + AutoMutex mutex(mMutex); + for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) + { + if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) ) { + mServerConn[jj] = NULL; + return true; + } + } + + // If here, not found + return false; +} +///////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////// + + +/******************************************************************************* +** +** Function: P2pClient +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +P2pClient::P2pClient () +: mNfaP2pClientHandle (NFA_HANDLE_INVALID), + mIsConnecting (false) +{ + mClientConn = new NfaConn(); +} + + +/******************************************************************************* +** +** Function: ~P2pClient +** +** Description: Free all resources. +** +** Returns: None +** +*******************************************************************************/ +P2pClient::~P2pClient () +{ +} + + +///////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////// + + +/******************************************************************************* +** +** Function: NfaConn +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +NfaConn::NfaConn() +: mNfaConnHandle (NFA_HANDLE_INVALID), + mJniHandle (0), + mMaxInfoUnit (0), + mRecvWindow (0), + mRemoteMaxInfoUnit (0), + mRemoteRecvWindow (0) +{ +} + diff --git a/nci/jni/PeerToPeer.h b/nci/jni/PeerToPeer.h new file mode 100644 index 0000000..3e8ffec --- /dev/null +++ b/nci/jni/PeerToPeer.h @@ -0,0 +1,779 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Communicate with a peer using NFC-DEP, LLCP, SNEP. + */ +#pragma once +#include +#include +#include "SyncEvent.h" +#include "NfcJniUtil.h" +#include +extern "C" +{ + #include "nfa_p2p_api.h" + #include "nfa_snep_api.h" +} + +class P2pServer; +class P2pClient; +class NfaConn; +#define MAX_NFA_CONNS_PER_SERVER 5 + +/***************************************************************************** +** +** Name: PeerToPeer +** +** Description: Communicate with a peer using NFC-DEP, LLCP, SNEP. +** +*****************************************************************************/ +class PeerToPeer +{ +public: + typedef unsigned int tJNI_HANDLE; + + /******************************************************************************* + ** + ** Function: PeerToPeer + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + PeerToPeer (); + + + /******************************************************************************* + ** + ** Function: ~PeerToPeer + ** + ** Description: Free all resources. + ** + ** Returns: None + ** + *******************************************************************************/ + ~PeerToPeer (); + + + /******************************************************************************* + ** + ** Function: getInstance + ** + ** Description: Get the singleton PeerToPeer object. + ** + ** Returns: Singleton PeerToPeer object. + ** + *******************************************************************************/ + static PeerToPeer& getInstance(); + + + /******************************************************************************* + ** + ** Function: initialize + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + void initialize (); + + + /******************************************************************************* + ** + ** Function: llcpActivatedHandler + ** + ** Description: Receive LLLCP-activated event from stack. + ** nat: JVM-related data. + ** activated: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + void llcpActivatedHandler (nfc_jni_native_data* nativeData, tNFA_LLCP_ACTIVATED& activated); + + + /******************************************************************************* + ** + ** Function: llcpDeactivatedHandler + ** + ** Description: Receive LLLCP-deactivated event from stack. + ** nat: JVM-related data. + ** deactivated: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + void llcpDeactivatedHandler (nfc_jni_native_data* nativeData, tNFA_LLCP_DEACTIVATED& deactivated); + + + /******************************************************************************* + ** + ** Function: connectionEventHandler + ** + ** Description: Receive events from the stack. + ** event: Event code. + ** eventData: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + void connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* eventData); + + + /******************************************************************************* + ** + ** Function: registerServer + ** + ** Description: Let a server start listening for peer's connection request. + ** jniHandle: Connection handle. + ** serviceName: Server's service name. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool registerServer (tJNI_HANDLE jniHandle, const char* serviceName); + + + /******************************************************************************* + ** + ** Function: deregisterServer + ** + ** Description: Stop a P2pServer from listening for peer. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool deregisterServer (tJNI_HANDLE jniHandle); + + + /******************************************************************************* + ** + ** Function: accept + ** + ** Description: Accept a peer's request to connect. + ** serverJniHandle: Server's handle. + ** connJniHandle: Connection handle. + ** maxInfoUnit: Maximum information unit. + ** recvWindow: Receive window size. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool accept (tJNI_HANDLE serverJniHandle, tJNI_HANDLE connJniHandle, int maxInfoUnit, int recvWindow); + + + /******************************************************************************* + ** + ** Function: createClient + ** + ** Description: Create a P2pClient object for a new out-bound connection. + ** jniHandle: Connection handle. + ** miu: Maximum information unit. + ** rw: Receive window size. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool createClient (tJNI_HANDLE jniHandle, UINT16 miu, UINT8 rw); + + + /******************************************************************************* + ** + ** Function: connectConnOriented + ** + ** Description: Estabish a connection-oriented connection to a peer. + ** jniHandle: Connection handle. + ** serviceName: Peer's service name. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool connectConnOriented (tJNI_HANDLE jniHandle, const char* serviceName); + + + /******************************************************************************* + ** + ** Function: connectConnOriented + ** + ** Description: Estabish a connection-oriented connection to a peer. + ** jniHandle: Connection handle. + ** destinationSap: Peer's service access point. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool connectConnOriented (tJNI_HANDLE jniHandle, UINT8 destinationSap); + + + /******************************************************************************* + ** + ** Function: send + ** + ** Description: Send data to peer. + ** jniHandle: Handle of connection. + ** buffer: Buffer of data. + ** bufferLen: Length of data. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool send (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen); + + + /******************************************************************************* + ** + ** Function: receive + ** + ** Description: Receive data from peer. + ** jniHandle: Handle of connection. + ** buffer: Buffer to store data. + ** bufferLen: Max length of buffer. + ** actualLen: Actual length received. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen, UINT16& actualLen); + + + /******************************************************************************* + ** + ** Function: disconnectConnOriented + ** + ** Description: Disconnect a connection-oriented connection with peer. + ** jniHandle: Handle of connection. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool disconnectConnOriented (tJNI_HANDLE jniHandle); + + + /******************************************************************************* + ** + ** Function: getRemoteMaxInfoUnit + ** + ** Description: Get peer's max information unit. + ** jniHandle: Handle of the connection. + ** + ** Returns: Peer's max information unit. + ** + *******************************************************************************/ + UINT16 getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle); + + + /******************************************************************************* + ** + ** Function: getRemoteRecvWindow + ** + ** Description: Get peer's receive window size. + ** jniHandle: Handle of the connection. + ** + ** Returns: Peer's receive window size. + ** + *******************************************************************************/ + UINT8 getRemoteRecvWindow (tJNI_HANDLE jniHandle); + + + /******************************************************************************* + ** + ** Function: setP2pListenMask + ** + ** Description: Sets the p2p listen technology mask. + ** p2pListenMask: the p2p listen mask to be set? + ** + ** Returns: None + ** + *******************************************************************************/ + void setP2pListenMask (tNFA_TECHNOLOGY_MASK p2pListenMask); + + /******************************************************************************* + ** + ** Function: enableP2pListening + ** + ** Description: Start/stop polling/listening to peer that supports P2P. + ** isEnable: Is enable polling/listening? + ** + ** Returns: None + ** + *******************************************************************************/ + void enableP2pListening (bool isEnable); + + + /******************************************************************************* + ** + ** Function: handleNfcOnOff + ** + ** Description: Handle events related to turning NFC on/off by the user. + ** isOn: Is NFC turning on? + ** + ** Returns: None + ** + *******************************************************************************/ + void handleNfcOnOff (bool isOn); + + + /******************************************************************************* + ** + ** Function: getNextJniHandle + ** + ** Description: Get a new JNI handle. + ** + ** Returns: A new JNI handle. + ** + *******************************************************************************/ + tJNI_HANDLE getNewJniHandle (); + + /******************************************************************************* + ** + ** Function: nfaServerCallback + ** + ** Description: Receive LLCP-related events from the stack. + ** p2pEvent: Event code. + ** eventData: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + static void nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA *eventData); + + + /******************************************************************************* + ** + ** Function: nfaClientCallback + ** + ** Description: Receive LLCP-related events from the stack. + ** p2pEvent: Event code. + ** eventData: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + static void nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA *eventData); + +private: + static const int sMax = 10; + static PeerToPeer sP2p; + + // Variables below only accessed from a single thread + UINT16 mRemoteWKS; // Peer's well known services + bool mIsP2pListening; // If P2P listening is enabled or not + tNFA_TECHNOLOGY_MASK mP2pListenTechMask; // P2P Listen mask + + // Variable below is protected by mNewJniHandleMutex + tJNI_HANDLE mNextJniHandle; + + // Variables below protected by mMutex + // A note on locking order: mMutex in PeerToPeer is *ALWAYS* + // locked before any locks / guards in P2pServer / P2pClient + Mutex mMutex; + android::sp mServers [sMax]; + android::sp mClients [sMax]; + + // Synchronization variables + SyncEvent mSetTechEvent; // completion event for NFA_SetP2pListenTech() + SyncEvent mSnepDefaultServerStartStopEvent; // completion event for NFA_SnepStartDefaultServer(), NFA_SnepStopDefaultServer() + SyncEvent mSnepRegisterEvent; // completion event for NFA_SnepRegisterClient() + Mutex mDisconnectMutex; // synchronize the disconnect operation + Mutex mNewJniHandleMutex; // synchronize the creation of a new JNI handle + + /******************************************************************************* + ** + ** Function: snepClientCallback + ** + ** Description: Receive SNEP-related events from the stack. + ** snepEvent: Event code. + ** eventData: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + static void snepClientCallback (tNFA_SNEP_EVT snepEvent, tNFA_SNEP_EVT_DATA *eventData); + + + /******************************************************************************* + ** + ** Function: ndefTypeCallback + ** + ** Description: Receive NDEF-related events from the stack. + ** ndefEvent: Event code. + ** eventData: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + static void ndefTypeCallback (tNFA_NDEF_EVT event, tNFA_NDEF_EVT_DATA *evetnData); + + + /******************************************************************************* + ** + ** Function: findServer + ** + ** Description: Find a PeerToPeer object by connection handle. + ** nfaP2pServerHandle: Connectin handle. + ** + ** Returns: PeerToPeer object. + ** + *******************************************************************************/ + android::sp findServerLocked (tNFA_HANDLE nfaP2pServerHandle); + + + /******************************************************************************* + ** + ** Function: findServer + ** + ** Description: Find a PeerToPeer object by connection handle. + ** serviceName: service name. + ** + ** Returns: PeerToPeer object. + ** + *******************************************************************************/ + android::sp findServerLocked (tJNI_HANDLE jniHandle); + + + /******************************************************************************* + ** + ** Function: findServer + ** + ** Description: Find a PeerToPeer object by service name + ** serviceName: service name. + ** + ** Returns: PeerToPeer object. + ** + *******************************************************************************/ + android::sp findServerLocked (const char *serviceName); + + + /******************************************************************************* + ** + ** Function: removeServer + ** + ** Description: Free resources related to a server. + ** jniHandle: Connection handle. + ** + ** Returns: None + ** + *******************************************************************************/ + void removeServer (tJNI_HANDLE jniHandle); + + + /******************************************************************************* + ** + ** Function: removeConn + ** + ** Description: Free resources related to a connection. + ** jniHandle: Connection handle. + ** + ** Returns: None + ** + *******************************************************************************/ + void removeConn (tJNI_HANDLE jniHandle); + + + /******************************************************************************* + ** + ** Function: createDataLinkConn + ** + ** Description: Establish a connection-oriented connection to a peer. + ** jniHandle: Connection handle. + ** serviceName: Peer's service name. + ** destinationSap: Peer's service access point. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceName, UINT8 destinationSap); + + + /******************************************************************************* + ** + ** Function: findClient + ** + ** Description: Find a PeerToPeer object with a client connection handle. + ** nfaConnHandle: Connection handle. + ** + ** Returns: PeerToPeer object. + ** + *******************************************************************************/ + android::sp findClient (tNFA_HANDLE nfaConnHandle); + + + /******************************************************************************* + ** + ** Function: findClient + ** + ** Description: Find a PeerToPeer object with a client connection handle. + ** jniHandle: Connection handle. + ** + ** Returns: PeerToPeer object. + ** + *******************************************************************************/ + android::sp findClient (tJNI_HANDLE jniHandle); + + + /******************************************************************************* + ** + ** Function: findClientCon + ** + ** Description: Find a PeerToPeer object with a client connection handle. + ** nfaConnHandle: Connection handle. + ** + ** Returns: PeerToPeer object. + ** + *******************************************************************************/ + android::sp findClientCon (tNFA_HANDLE nfaConnHandle); + + + /******************************************************************************* + ** + ** Function: findConnection + ** + ** Description: Find a PeerToPeer object with a connection handle. + ** nfaConnHandle: Connection handle. + ** + ** Returns: PeerToPeer object. + ** + *******************************************************************************/ + android::sp findConnection (tNFA_HANDLE nfaConnHandle); + + + /******************************************************************************* + ** + ** Function: findConnection + ** + ** Description: Find a PeerToPeer object with a connection handle. + ** jniHandle: Connection handle. + ** + ** Returns: PeerToPeer object. + ** + *******************************************************************************/ + android::sp findConnection (tJNI_HANDLE jniHandle); +}; + + +/***************************************************************************** +** +** Name: NfaConn +** +** Description: Store information about a connection related to a peer. +** +*****************************************************************************/ +class NfaConn : public android::RefBase +{ +public: + tNFA_HANDLE mNfaConnHandle; // NFA handle of the P2P connection + PeerToPeer::tJNI_HANDLE mJniHandle; // JNI handle of the P2P connection + UINT16 mMaxInfoUnit; + UINT8 mRecvWindow; + UINT16 mRemoteMaxInfoUnit; + UINT8 mRemoteRecvWindow; + SyncEvent mReadEvent; // event for reading + SyncEvent mCongEvent; // event for congestion + SyncEvent mDisconnectingEvent; // event for disconnecting + + + /******************************************************************************* + ** + ** Function: NfaConn + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + NfaConn(); +}; + + +/***************************************************************************** +** +** Name: P2pServer +** +** Description: Store information about an in-bound connection from a peer. +** +*****************************************************************************/ +class P2pServer : public android::RefBase +{ +public: + static const std::string sSnepServiceName; + + tNFA_HANDLE mNfaP2pServerHandle; // NFA p2p handle of local server + PeerToPeer::tJNI_HANDLE mJniHandle; // JNI Handle + SyncEvent mRegServerEvent; // for NFA_P2pRegisterServer() + SyncEvent mConnRequestEvent; // for accept() + std::string mServiceName; + + /******************************************************************************* + ** + ** Function: P2pServer + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + P2pServer (PeerToPeer::tJNI_HANDLE jniHandle, const char* serviceName); + + /******************************************************************************* + ** + ** Function: registerWithStack + ** + ** Description: Register this server with the stack. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool registerWithStack(); + + /******************************************************************************* + ** + ** Function: accept + ** + ** Description: Accept a peer's request to connect. + ** serverJniHandle: Server's handle. + ** connJniHandle: Connection handle. + ** maxInfoUnit: Maximum information unit. + ** recvWindow: Receive window size. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool accept (PeerToPeer::tJNI_HANDLE serverJniHandle, PeerToPeer::tJNI_HANDLE connJniHandle, + int maxInfoUnit, int recvWindow); + + /******************************************************************************* + ** + ** Function: unblockAll + ** + ** Description: Unblocks all server connections + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + void unblockAll(); + + /******************************************************************************* + ** + ** Function: findServerConnection + ** + ** Description: Find a P2pServer that has the handle. + ** nfaConnHandle: NFA connection handle. + ** + ** Returns: P2pServer object. + ** + *******************************************************************************/ + android::sp findServerConnection (tNFA_HANDLE nfaConnHandle); + + /******************************************************************************* + ** + ** Function: findServerConnection + ** + ** Description: Find a P2pServer that has the handle. + ** jniHandle: JNI connection handle. + ** + ** Returns: P2pServer object. + ** + *******************************************************************************/ + android::sp findServerConnection (PeerToPeer::tJNI_HANDLE jniHandle); + + /******************************************************************************* + ** + ** Function: removeServerConnection + ** + ** Description: Remove a server connection with the provided handle. + ** jniHandle: JNI connection handle. + ** + ** Returns: True if connection found and removed. + ** + *******************************************************************************/ + bool removeServerConnection(PeerToPeer::tJNI_HANDLE jniHandle); + +private: + Mutex mMutex; + // mServerConn is protected by mMutex + android::sp mServerConn[MAX_NFA_CONNS_PER_SERVER]; + + /******************************************************************************* + ** + ** Function: allocateConnection + ** + ** Description: Allocate a new connection to accept on + ** jniHandle: JNI connection handle. + ** + ** Returns: Allocated connection object + ** NULL if the maximum number of connections was reached + ** + *******************************************************************************/ + android::sp allocateConnection (PeerToPeer::tJNI_HANDLE jniHandle); +}; + + +/***************************************************************************** +** +** Name: P2pClient +** +** Description: Store information about an out-bound connection to a peer. +** +*****************************************************************************/ +class P2pClient : public android::RefBase +{ +public: + tNFA_HANDLE mNfaP2pClientHandle; // NFA p2p handle of client + bool mIsConnecting; // Set true while connecting + android::sp mClientConn; + SyncEvent mRegisteringEvent; // For client registration + SyncEvent mConnectingEvent; // for NFA_P2pConnectByName or Sap() + SyncEvent mSnepEvent; // To wait for SNEP completion + + /******************************************************************************* + ** + ** Function: P2pClient + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + P2pClient (); + + + /******************************************************************************* + ** + ** Function: ~P2pClient + ** + ** Description: Free all resources. + ** + ** Returns: None + ** + *******************************************************************************/ + ~P2pClient (); + + + /******************************************************************************* + ** + ** Function: unblock + ** + ** Description: Unblocks any threads that are locked on this connection + ** + ** Returns: None + ** + *******************************************************************************/ + void unblock(); +}; + diff --git a/nci/jni/Pn544Interop.cpp b/nci/jni/Pn544Interop.cpp new file mode 100644 index 0000000..be92c75 --- /dev/null +++ b/nci/jni/Pn544Interop.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/***************************************************************************** +** +** Name: Pn544Interop.cpp +** +** Description: Implement operations that provide compatibility with NXP +** PN544 controller. Specifically facilitate peer-to-peer +** operations with PN544 controller. +** +*****************************************************************************/ +#include "OverrideLog.h" +#include "Pn544Interop.h" +#include "IntervalTimer.h" +#include "Mutex.h" +#include "NfcTag.h" +namespace android +{ + extern void startStopPolling (bool isStartPolling); +} + + +/***************************************************************************** +** +** private variables and functions +** +*****************************************************************************/ + + +static const int gIntervalTime = 1000; //millisecond between the check to restore polling +static IntervalTimer gTimer; +static Mutex gMutex; +static void pn544InteropStartPolling (union sigval); //callback function for interval timer +static bool gIsBusy = false; //is timer busy? +static bool gAbortNow = false; //stop timer during next callback + + +/******************************************************************************* +** +** Function: pn544InteropStopPolling +** +** Description: Stop polling to let NXP PN544 controller poll. +** PN544 should activate in P2P mode. +** +** Returns: None +** +*******************************************************************************/ +void pn544InteropStopPolling () +{ + ALOGD ("%s: enter", __FUNCTION__); + gMutex.lock (); + gTimer.kill (); + android::startStopPolling (false); + gIsBusy = true; + gAbortNow = false; + gTimer.set (gIntervalTime, pn544InteropStartPolling); //after some time, start polling again + gMutex.unlock (); + ALOGD ("%s: exit", __FUNCTION__); +} + + +/******************************************************************************* +** +** Function: pn544InteropStartPolling +** +** Description: Start polling when activation state is idle. +** sigval: Unused. +** +** Returns: None +** +*******************************************************************************/ +void pn544InteropStartPolling (union sigval) +{ + ALOGD ("%s: enter", __FUNCTION__); + gMutex.lock (); + NfcTag::ActivationState state = NfcTag::getInstance ().getActivationState (); + + if (gAbortNow) + { + ALOGD ("%s: abort now", __FUNCTION__); + gIsBusy = false; + goto TheEnd; + } + + if (state == NfcTag::Idle) + { + ALOGD ("%s: start polling", __FUNCTION__); + android::startStopPolling (true); + gIsBusy = false; + } + else + { + ALOGD ("%s: try again later", __FUNCTION__); + gTimer.set (gIntervalTime, pn544InteropStartPolling); //after some time, start polling again + } + +TheEnd: + gMutex.unlock (); + ALOGD ("%s: exit", __FUNCTION__); +} + + +/******************************************************************************* +** +** Function: pn544InteropIsBusy +** +** Description: Is the code performing operations? +** +** Returns: True if the code is busy. +** +*******************************************************************************/ +bool pn544InteropIsBusy () +{ + bool isBusy = false; + gMutex.lock (); + isBusy = gIsBusy; + gMutex.unlock (); + ALOGD ("%s: %u", __FUNCTION__, isBusy); + return isBusy; +} + + +/******************************************************************************* +** +** Function: pn544InteropAbortNow +** +** Description: Request to abort all operations. +** +** Returns: None. +** +*******************************************************************************/ +void pn544InteropAbortNow () +{ + ALOGD ("%s", __FUNCTION__); + gMutex.lock (); + gAbortNow = true; + gMutex.unlock (); +} + diff --git a/nci/jni/Pn544Interop.h b/nci/jni/Pn544Interop.h new file mode 100644 index 0000000..c9a2df6 --- /dev/null +++ b/nci/jni/Pn544Interop.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/***************************************************************************** +** +** Name: Pn544Interop.h +** +** Description: Implement operations that provide compatibility with NXP +** PN544 controller. Specifically facilitate peer-to-peer +** operations with PN544 controller. +** +*****************************************************************************/ +#pragma once +#include "NfcJniUtil.h" + + +/******************************************************************************* +** +** Function: pn544InteropStopPolling +** +** Description: Stop polling to let NXP PN544 controller poll. +** PN544 should activate in P2P mode. +** +** Returns: None +** +*******************************************************************************/ +void pn544InteropStopPolling (); + + +/******************************************************************************* +** +** Function: pn544InteropIsBusy +** +** Description: Is the code performing operations? +** +** Returns: True if the code is busy. +** +*******************************************************************************/ +bool pn544InteropIsBusy (); + + +/******************************************************************************* +** +** Function: pn544InteropAbortNow +** +** Description: Request to abort all operations. +** +** Returns: None. +** +*******************************************************************************/ +void pn544InteropAbortNow (); diff --git a/nci/jni/PowerSwitch.cpp b/nci/jni/PowerSwitch.cpp new file mode 100755 index 0000000..9d58c74 --- /dev/null +++ b/nci/jni/PowerSwitch.cpp @@ -0,0 +1,439 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Adjust the controller's power states. + */ +#include "OverrideLog.h" +#include "PowerSwitch.h" +#include "NfcJniUtil.h" +#include "config.h" +#include "SecureElement.h" + + +namespace android +{ + void doStartupConfig (); +} + + +PowerSwitch PowerSwitch::sPowerSwitch; +const PowerSwitch::PowerActivity PowerSwitch::DISCOVERY=0x01; +const PowerSwitch::PowerActivity PowerSwitch::SE_ROUTING=0x02; +const PowerSwitch::PowerActivity PowerSwitch::SE_CONNECTED=0x04; + +/******************************************************************************* +** +** Function: PowerSwitch +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +PowerSwitch::PowerSwitch () +: mCurrLevel (UNKNOWN_LEVEL), + mCurrDeviceMgtPowerState (NFA_DM_PWR_STATE_UNKNOWN), + mDesiredScreenOffPowerState (0), + mCurrActivity(0) +{ +} + + +/******************************************************************************* +** +** Function: ~PowerSwitch +** +** Description: Release all resources. +** +** Returns: None +** +*******************************************************************************/ +PowerSwitch::~PowerSwitch () +{ +} + + +/******************************************************************************* +** +** Function: getInstance +** +** Description: Get the singleton of this object. +** +** Returns: Reference to this object. +** +*******************************************************************************/ +PowerSwitch& PowerSwitch::getInstance () +{ + return sPowerSwitch; +} + + +/******************************************************************************* +** +** Function: initialize +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +void PowerSwitch::initialize (PowerLevel level) +{ + static const char fn [] = "PowerSwitch::initialize"; + + mMutex.lock (); + + ALOGD ("%s: level=%s (%u)", fn, powerLevelToString(level), level); + GetNumValue (NAME_SCREEN_OFF_POWER_STATE, &mDesiredScreenOffPowerState, sizeof(mDesiredScreenOffPowerState)); + ALOGD ("%s: desired screen-off state=%d", fn, mDesiredScreenOffPowerState); + + switch (level) + { + case FULL_POWER: + mCurrDeviceMgtPowerState = NFA_DM_PWR_MODE_FULL; + mCurrLevel = level; + break; + + case UNKNOWN_LEVEL: + mCurrDeviceMgtPowerState = NFA_DM_PWR_STATE_UNKNOWN; + mCurrLevel = level; + break; + + default: + ALOGE ("%s: not handled", fn); + break; + } + mMutex.unlock (); +} + + +/******************************************************************************* +** +** Function: getLevel +** +** Description: Get the current power level of the controller. +** +** Returns: Power level. +** +*******************************************************************************/ +PowerSwitch::PowerLevel PowerSwitch::getLevel () +{ + PowerLevel level = UNKNOWN_LEVEL; + mMutex.lock (); + level = mCurrLevel; + mMutex.unlock (); + return level; +} + + +/******************************************************************************* +** +** 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; + } + + 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; + } + +TheEnd: + mMutex.unlock (); + return retval; +} + +/******************************************************************************* +** +** Function: setModeOff +** +** Description: Set a mode to be deactive. +** +** Returns: True if any mode is still active. +** +*******************************************************************************/ +bool PowerSwitch::setModeOff (PowerActivity deactivated) +{ + bool retVal = false; + + mMutex.lock (); + mCurrActivity &= ~deactivated; + retVal = mCurrActivity != 0; + ALOGD ("PowerSwitch::setModeOff(deactivated=0x%x) : mCurrActivity=0x%x", deactivated, mCurrActivity); + mMutex.unlock (); + return retVal; +} + + +/******************************************************************************* +** +** Function: setModeOn +** +** Description: Set a mode to be active. +** +** Returns: True if any mode is active. +** +*******************************************************************************/ +bool PowerSwitch::setModeOn (PowerActivity activated) +{ + bool retVal = false; + + mMutex.lock (); + mCurrActivity |= activated; + retVal = mCurrActivity != 0; + ALOGD ("PowerSwitch::setModeOn(activated=0x%x) : mCurrActivity=0x%x", activated, mCurrActivity); + mMutex.unlock (); + return retVal; +} + + +/******************************************************************************* +** +** Function: setPowerOffSleepState +** +** Description: Adjust controller's power-off-sleep state. +** sleep: whether to enter sleep state. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool PowerSwitch::setPowerOffSleepState (bool sleep) +{ + static const char fn [] = "PowerSwitch::setPowerOffSleepState"; + ALOGD ("%s: enter; sleep=%u", fn, sleep); + tNFA_STATUS stat = NFA_STATUS_FAILED; + bool retval = false; + + if (sleep) //enter power-off-sleep state + { + //make sure the current power state is ON + if (mCurrDeviceMgtPowerState != NFA_DM_PWR_MODE_OFF_SLEEP) + { + SyncEventGuard guard (mPowerStateEvent); + ALOGD ("%s: try power off", fn); + stat = NFA_PowerOffSleepMode (TRUE); + if (stat == NFA_STATUS_OK) + { + mPowerStateEvent.wait (); + mCurrLevel = LOW_POWER; + } + else + { + ALOGE ("%s: API fail; stat=0x%X", fn, stat); + goto TheEnd; + } + } + else + { + ALOGE ("%s: power is not ON; curr device mgt power state=%s (%u)", fn, + deviceMgtPowerStateToString (mCurrDeviceMgtPowerState), mCurrDeviceMgtPowerState); + goto TheEnd; + } + } + else //exit power-off-sleep state + { + //make sure the current power state is OFF + if (mCurrDeviceMgtPowerState != NFA_DM_PWR_MODE_FULL) + { + mCurrDeviceMgtPowerState = NFA_DM_PWR_STATE_UNKNOWN; + SyncEventGuard guard (mPowerStateEvent); + ALOGD ("%s: try full power", fn); + stat = NFA_PowerOffSleepMode (FALSE); + if (stat == NFA_STATUS_OK) + { + mPowerStateEvent.wait (); + if (mCurrDeviceMgtPowerState != NFA_DM_PWR_MODE_FULL) + { + ALOGE ("%s: unable to full power; curr device mgt power stat=%s (%u)", fn, + deviceMgtPowerStateToString (mCurrDeviceMgtPowerState), mCurrDeviceMgtPowerState); + goto TheEnd; + } + android::doStartupConfig (); + mCurrLevel = FULL_POWER; + } + else + { + ALOGE ("%s: API fail; stat=0x%X", fn, stat); + goto TheEnd; + } + } + else + { + ALOGE ("%s: not in power-off state; curr device mgt power state=%s (%u)", fn, + deviceMgtPowerStateToString (mCurrDeviceMgtPowerState), mCurrDeviceMgtPowerState); + goto TheEnd; + } + } + + retval = true; +TheEnd: + ALOGD ("%s: exit; return %u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: deviceMgtPowerStateToString +** +** Description: Decode power level to a string. +** deviceMgtPowerState: power level. +** +** Returns: Text representation of power level. +** +*******************************************************************************/ +const char* PowerSwitch::deviceMgtPowerStateToString (UINT8 deviceMgtPowerState) +{ + switch (deviceMgtPowerState) + { + case NFA_DM_PWR_MODE_FULL: + return "DM-FULL"; + case NFA_DM_PWR_MODE_OFF_SLEEP: + return "DM-OFF"; + default: + return "DM-unknown????"; + } +} + + +/******************************************************************************* +** +** Function: powerLevelToString +** +** Description: Decode power level to a string. +** level: power level. +** +** Returns: Text representation of power level. +** +*******************************************************************************/ +const char* PowerSwitch::powerLevelToString (PowerLevel level) +{ + switch (level) + { + case UNKNOWN_LEVEL: + return "PS-UNKNOWN"; + case FULL_POWER: + return "PS-FULL"; + case LOW_POWER: + return "PS-LOW-POWER"; + case POWER_OFF: + return "PS-POWER-OFF"; + default: + return "PS-unknown????"; + } +} + + +/******************************************************************************* +** +** Function: abort +** +** Description: Abort and unblock currrent operation. +** +** Returns: None +** +*******************************************************************************/ +void PowerSwitch::abort () +{ + static const char fn [] = "PowerSwitch::abort"; + ALOGD ("%s", fn); + SyncEventGuard guard (mPowerStateEvent); + mPowerStateEvent.notifyOne (); +} + + +/******************************************************************************* +** +** Function: deviceManagementCallback +** +** Description: Callback function for the stack. +** event: event ID. +** eventData: event's data. +** +** Returns: None +** +*******************************************************************************/ +void PowerSwitch::deviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA* eventData) +{ + static const char fn [] = "PowerSwitch::deviceManagementCallback"; + + switch (event) + { + case NFA_DM_PWR_MODE_CHANGE_EVT: + { + tNFA_DM_PWR_MODE_CHANGE& power_mode = eventData->power_mode; + ALOGD ("%s: NFA_DM_PWR_MODE_CHANGE_EVT; status=%u; device mgt power mode=%s (%u)", fn, + power_mode.status, sPowerSwitch.deviceMgtPowerStateToString (power_mode.power_mode), power_mode.power_mode); + SyncEventGuard guard (sPowerSwitch.mPowerStateEvent); + if (power_mode.status == NFA_STATUS_OK) + sPowerSwitch.mCurrDeviceMgtPowerState = power_mode.power_mode; + sPowerSwitch.mPowerStateEvent.notifyOne (); + } + break; + } +} + + +/******************************************************************************* +** +** Function: isPowerOffSleepFeatureEnabled +** +** Description: Whether power-off-sleep feature is enabled in .conf file. +** +** Returns: True if feature is enabled. +** +*******************************************************************************/ +bool PowerSwitch::isPowerOffSleepFeatureEnabled () +{ + return mDesiredScreenOffPowerState == 0; +} + diff --git a/nci/jni/PowerSwitch.h b/nci/jni/PowerSwitch.h new file mode 100755 index 0000000..d311c23 --- /dev/null +++ b/nci/jni/PowerSwitch.h @@ -0,0 +1,258 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Adjust the controller's power states. + */ +#pragma once +#include "nfa_api.h" +#include "SyncEvent.h" + + +/***************************************************************************** +** +** Name: PowerSwitch +** +** Description: Adjust the controller's power states. +** +*****************************************************************************/ +class PowerSwitch +{ +public: + + + /******************************************************************************* + ** + ** Description: UNKNOWN_LEVEL: power level is unknown because the stack is off. + ** FULL_POWER: controller is in full-power state. + ** LOW_POWER: controller is in lower-power state. + ** + *******************************************************************************/ + enum PowerLevel {UNKNOWN_LEVEL, FULL_POWER, LOW_POWER, POWER_OFF}; + + /******************************************************************************* + ** + ** Description: DISCOVERY: Discovery is enabled + ** SE_ROUTING: Routing to SE is enabled. + ** SE_CONNECTED: SE is connected. + ** + *******************************************************************************/ + typedef int PowerActivity; + static const PowerActivity DISCOVERY; + static const PowerActivity SE_ROUTING; + static const PowerActivity SE_CONNECTED; + + /******************************************************************************* + ** + ** Description: Platform Power Level, copied from NativeNfcBrcmPowerMode.java. + ** UNKNOWN_LEVEL: power level is unknown. + ** POWER_OFF: The phone is turned OFF + ** SCREEN_OFF: The phone is turned ON but screen is OFF + ** SCREEN_ON_LOCKED: The phone is turned ON, screen is ON but user locked + ** SCREEN_ON_UNLOCKED: The phone is turned ON, screen is ON, and user unlocked + ** + *******************************************************************************/ + static const int PLATFORM_UNKNOWN_LEVEL = 0; + static const int PLATFORM_POWER_OFF = 1; + static const int PLATFORM_SCREEN_OFF = 2; + static const int PLATFORM_SCREEN_ON_LOCKED = 3; + static const int PLATFORM_SCREEN_ON_UNLOCKED = 4; + + static const int VBAT_MONITOR_ENABLED = 1; + static const int VBAT_MONITOR_PRIMARY_THRESHOLD = 5; + static const int VBAT_MONITOR_SECONDARY_THRESHOLD = 8; + /******************************************************************************* + ** + ** Function: PowerSwitch + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + PowerSwitch (); + + + /******************************************************************************* + ** + ** Function: ~PowerSwitch + ** + ** Description: Release all resources. + ** + ** Returns: None + ** + *******************************************************************************/ + ~PowerSwitch (); + + + /******************************************************************************* + ** + ** Function: getInstance + ** + ** Description: Get the singleton of this object. + ** + ** Returns: Reference to this object. + ** + *******************************************************************************/ + static PowerSwitch& getInstance (); + + /******************************************************************************* + ** + ** Function: initialize + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + void initialize (PowerLevel level); + + + /******************************************************************************* + ** + ** Function: getLevel + ** + ** Description: Get the current power level of the controller. + ** + ** Returns: Power level. + ** + *******************************************************************************/ + PowerLevel getLevel (); + + + /******************************************************************************* + ** + ** Function: setLevel + ** + ** Description: Set the controller's power level. + ** level: power level. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool setLevel (PowerLevel level); + + + /******************************************************************************* + ** + ** Function: setModeOff + ** + ** Description: Set a mode to be deactive. + ** + ** Returns: True if any mode is still active. + ** + *******************************************************************************/ + bool setModeOff (PowerActivity deactivated); + + + /******************************************************************************* + ** + ** Function: setModeOn + ** + ** Description: Set a mode to be active. + ** + ** Returns: True if any mode is active. + ** + *******************************************************************************/ + bool setModeOn (PowerActivity activated); + + + /******************************************************************************* + ** + ** Function: abort + ** + ** Description: Abort and unblock currrent operation. + ** + ** Returns: None + ** + *******************************************************************************/ + void abort (); + + + /******************************************************************************* + ** + ** Function: deviceManagementCallback + ** + ** Description: Callback function for the stack. + ** event: event ID. + ** eventData: event's data. + ** + ** Returns: None + ** + *******************************************************************************/ + static void deviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA* eventData); + + + /******************************************************************************* + ** + ** Function: isPowerOffSleepFeatureEnabled + ** + ** Description: Whether power-off-sleep feature is enabled in .conf file. + ** + ** Returns: True if feature is enabled. + ** + *******************************************************************************/ + bool isPowerOffSleepFeatureEnabled (); + +private: + PowerLevel mCurrLevel; + UINT8 mCurrDeviceMgtPowerState; //device management power state; such as NFA_DM_PWR_STATE_??? + int mDesiredScreenOffPowerState; //read from .conf file; 0=power-off-sleep; 1=full power; 2=CE4 power + static PowerSwitch sPowerSwitch; //singleton object + static const UINT8 NFA_DM_PWR_STATE_UNKNOWN = -1; //device management power state power state is unknown + SyncEvent mPowerStateEvent; + PowerActivity mCurrActivity; + Mutex mMutex; + + + /******************************************************************************* + ** + ** Function: setPowerOffSleepState + ** + ** Description: Adjust controller's power-off-sleep state. + ** sleep: whether to enter sleep state. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool setPowerOffSleepState (bool sleep); + + + /******************************************************************************* + ** + ** Function: deviceMgtPowerStateToString + ** + ** Description: Decode power level to a string. + ** deviceMgtPowerState: power level. + ** + ** Returns: Text representation of power level. + ** + *******************************************************************************/ + const char* deviceMgtPowerStateToString (UINT8 deviceMgtPowerState); + + + /******************************************************************************* + ** + ** Function: powerLevelToString + ** + ** Description: Decode power level to a string. + ** level: power level. + ** + ** Returns: Text representation of power level. + ** + *******************************************************************************/ + const char* powerLevelToString (PowerLevel level); +}; diff --git a/nci/jni/RouteDataSet.cpp b/nci/jni/RouteDataSet.cpp new file mode 100644 index 0000000..1458776 --- /dev/null +++ b/nci/jni/RouteDataSet.cpp @@ -0,0 +1,555 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Import and export general routing data using a XML file. + */ +#include "OverrideLog.h" +#include "RouteDataSet.h" +#include "libxml/xmlmemory.h" +#include +#include + +extern char bcm_nfc_location[]; + + +/******************************************************************************* +** +** Function: AidBuffer +** +** Description: Parse a string of hex numbers. Store result in an array of +** bytes. +** aid: string of hex numbers. +** +** Returns: None. +** +*******************************************************************************/ +AidBuffer::AidBuffer (std::string& aid) +: mBuffer (NULL), + mBufferLen (0) +{ + unsigned int num = 0; + const char delimiter = ':'; + std::string::size_type pos1 = 0; + std::string::size_type pos2 = aid.find_first_of (delimiter); + + //parse the AID string; each hex number is separated by a colon; + mBuffer = new UINT8 [aid.length()]; + while (true) + { + num = 0; + if (pos2 == std::string::npos) + { + sscanf (aid.substr(pos1).c_str(), "%x", &num); + mBuffer [mBufferLen] = (UINT8) num; + mBufferLen++; + break; + } + else + { + sscanf (aid.substr(pos1, pos2-pos1+1).c_str(), "%x", &num); + mBuffer [mBufferLen] = (UINT8) num; + mBufferLen++; + pos1 = pos2 + 1; + pos2 = aid.find_first_of (delimiter, pos1); + } + } +} + + +/******************************************************************************* +** +** Function: ~AidBuffer +** +** Description: Release all resources. +** +** Returns: None. +** +*******************************************************************************/ +AidBuffer::~AidBuffer () +{ + delete [] mBuffer; +} + + +/*******************************************************************************/ +/*******************************************************************************/ + + +const char* RouteDataSet::sConfigFile = "/param/route.xml"; + + +/******************************************************************************* +** +** Function: ~RouteDataSet +** +** Description: Release all resources. +** +** Returns: None. +** +*******************************************************************************/ +RouteDataSet::~RouteDataSet () +{ + deleteDatabase (); +} + + +/******************************************************************************* +** +** Function: initialize +** +** Description: Initialize resources. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool RouteDataSet::initialize () +{ + static const char fn [] = "RouteDataSet::initialize"; + ALOGD ("%s: enter", fn); + //check that the libxml2 version in use is compatible + //with the version the software has been compiled with + LIBXML_TEST_VERSION + ALOGD ("%s: exit; return=true", fn); + return true; +} + + +/******************************************************************************* +** +** Function: deleteDatabase +** +** Description: Delete all routes stored in all databases. +** +** Returns: None. +** +*******************************************************************************/ +void RouteDataSet::deleteDatabase () +{ + static const char fn [] = "RouteDataSet::deleteDatabase"; + ALOGD ("%s: default db size=%u; sec elem db size=%u", fn, mDefaultRouteDatabase.size(), mSecElemRouteDatabase.size()); + Database::iterator it; + + for (it = mDefaultRouteDatabase.begin(); it != mDefaultRouteDatabase.end(); it++) + delete (*it); + mDefaultRouteDatabase.clear (); + + for (it = mSecElemRouteDatabase.begin(); it != mSecElemRouteDatabase.end(); it++) + delete (*it); + mSecElemRouteDatabase.clear (); +} + + +/******************************************************************************* +** +** Function: import +** +** Description: Import data from an XML file. Fill the databases. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool RouteDataSet::import () +{ + static const char fn [] = "RouteDataSet::import"; + ALOGD ("%s: enter", fn); + bool retval = false; + xmlDocPtr doc; + xmlNodePtr node1; + std::string strFilename(bcm_nfc_location); + strFilename += sConfigFile; + + deleteDatabase (); + + doc = xmlParseFile (strFilename.c_str()); + if (doc == NULL) + { + ALOGD ("%s: fail parse", fn); + goto TheEnd; + } + + node1 = xmlDocGetRootElement (doc); + if (node1 == NULL) + { + ALOGE ("%s: fail root element", fn); + goto TheEnd; + } + ALOGD ("%s: root=%s", fn, node1->name); + + node1 = node1->xmlChildrenNode; + while (node1) //loop through all elements in name, (const xmlChar*) "Route")==0) + { + xmlChar* value = xmlGetProp (node1, (const xmlChar*) "Type"); + if (value && (xmlStrcmp (value, (const xmlChar*) "SecElemSelectedRoutes") == 0)) + { + ALOGD ("%s: found SecElemSelectedRoutes", fn); + xmlNodePtr node2 = node1->xmlChildrenNode; + while (node2) //loop all elements in name, (const xmlChar*) "Proto")==0) + importProtocolRoute (node2, mSecElemRouteDatabase); + else if (xmlStrcmp(node2->name, (const xmlChar*) "Tech")==0) + importTechnologyRoute (node2, mSecElemRouteDatabase); + node2 = node2->next; + } //loop all elements in xmlChildrenNode; + while (node2) //loop all elements in name, (const xmlChar*) "Proto")==0) + importProtocolRoute (node2, mDefaultRouteDatabase); + else if (xmlStrcmp(node2->name, (const xmlChar*) "Tech")==0) + importTechnologyRoute (node2, mDefaultRouteDatabase); + node2 = node2->next; + } //loop all elements in next; + } //loop through all elements in name); + value = xmlGetProp (element, id); + if (value) + { + if (xmlStrcmp (value, (const xmlChar*) "T1T") == 0) + data->mProtocol = NFA_PROTOCOL_MASK_T1T; + else if (xmlStrcmp (value, (const xmlChar*) "T2T") == 0) + data->mProtocol = NFA_PROTOCOL_MASK_T2T; + else if (xmlStrcmp (value, (const xmlChar*) "T3T") == 0) + data->mProtocol = NFA_PROTOCOL_MASK_T3T; + else if (xmlStrcmp (value, (const xmlChar*) "IsoDep") == 0) + data->mProtocol = NFA_PROTOCOL_MASK_ISO_DEP; + xmlFree (value); + ALOGD_IF (sDebug, "%s: %s=0x%X", fn, id, data->mProtocol); + } + + value = xmlGetProp (element, secElem); + if (value) + { + data->mNfaEeHandle = strtol ((char*) value, NULL, 16); + xmlFree (value); + data->mNfaEeHandle = data->mNfaEeHandle | NFA_HANDLE_GROUP_EE; + ALOGD_IF (sDebug, "%s: %s=0x%X", fn, secElem, data->mNfaEeHandle); + } + + value = xmlGetProp (element, switchOn); + if (value) + { + data->mSwitchOn = (xmlStrcmp (value, trueString) == 0); + xmlFree (value); + } + + value = xmlGetProp (element, switchOff); + if (value) + { + data->mSwitchOff = (xmlStrcmp (value, trueString) == 0); + xmlFree (value); + } + + value = xmlGetProp (element, batteryOff); + if (value) + { + data->mBatteryOff = (xmlStrcmp (value, trueString) == 0); + xmlFree (value); + } + database.push_back (data); +} + + +/******************************************************************************* +** +** Function: importTechnologyRoute +** +** Description: Parse data for technology routes. +** element: XML node for one technology route. +** database: store data in this database. +** +** Returns: None. +** +*******************************************************************************/ +void RouteDataSet::importTechnologyRoute (xmlNodePtr& element, Database& database) +{ + static const char fn [] = "RouteDataSet::importTechnologyRoute"; + const xmlChar* id = (const xmlChar*) "Id"; + const xmlChar* secElem = (const xmlChar*) "SecElem"; + const xmlChar* trueString = (const xmlChar*) "true"; + const xmlChar* switchOn = (const xmlChar*) "SwitchOn"; + const xmlChar* switchOff = (const xmlChar*) "SwitchOff"; + const xmlChar* batteryOff = (const xmlChar*) "BatteryOff"; + RouteDataForTechnology* data = new RouteDataForTechnology; + xmlChar* value = NULL; + + ALOGD_IF (sDebug, "%s: element=%s", fn, element->name); + value = xmlGetProp (element, id); + if (value) + { + if (xmlStrcmp (value, (const xmlChar*) "NfcA") == 0) + data->mTechnology = NFA_TECHNOLOGY_MASK_A; + else if (xmlStrcmp (value, (const xmlChar*) "NfcB") == 0) + data->mTechnology = NFA_TECHNOLOGY_MASK_B; + else if (xmlStrcmp (value, (const xmlChar*) "NfcF") == 0) + data->mTechnology = NFA_TECHNOLOGY_MASK_F; + xmlFree (value); + ALOGD_IF (sDebug, "%s: %s=0x%X", fn, id, data->mTechnology); + } + + value = xmlGetProp (element, secElem); + if (value) + { + data->mNfaEeHandle = strtol ((char*) value, NULL, 16); + xmlFree (value); + data->mNfaEeHandle = data->mNfaEeHandle | NFA_HANDLE_GROUP_EE; + ALOGD_IF (sDebug, "%s: %s=0x%X", fn, secElem, data->mNfaEeHandle); + } + + value = xmlGetProp (element, switchOn); + if (value) + { + data->mSwitchOn = (xmlStrcmp (value, trueString) == 0); + xmlFree (value); + } + + value = xmlGetProp (element, switchOff); + if (value) + { + data->mSwitchOff = (xmlStrcmp (value, trueString) == 0); + xmlFree (value); + } + + value = xmlGetProp (element, batteryOff); + if (value) + { + data->mBatteryOff = (xmlStrcmp (value, trueString) == 0); + xmlFree (value); + } + database.push_back (data); +} + + +/******************************************************************************* +** +** Function: deleteFile +** +** Description: Delete route data XML file. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool RouteDataSet::deleteFile () +{ + static const char fn [] = "RouteDataSet::deleteFile"; + std::string filename (bcm_nfc_location); + filename.append (sConfigFile); + int stat = remove (filename.c_str()); + ALOGD ("%s: exit %u", fn, stat==0); + return stat == 0; +} + + +/******************************************************************************* +** +** Function: getDatabase +** +** Description: Obtain a database of routing data. +** selection: which database. +** +** Returns: Pointer to database. +** +*******************************************************************************/ +RouteDataSet::Database* RouteDataSet::getDatabase (DatabaseSelection selection) +{ + switch (selection) + { + case DefaultRouteDatabase: + return &mDefaultRouteDatabase; + case SecElemRouteDatabase: + return &mSecElemRouteDatabase; + } + return NULL; +} + + +/******************************************************************************* +** +** Function: printDiagnostic +** +** Description: Print some diagnostic output. +** +** Returns: None. +** +*******************************************************************************/ +void RouteDataSet::printDiagnostic () +{ + static const char fn [] = "RouteDataSet::printDiagnostic"; + Database* db = getDatabase (DefaultRouteDatabase); + + ALOGD ("%s: default route database", fn); + for (Database::iterator iter = db->begin(); iter != db->end(); iter++) + { + RouteData* routeData = *iter; + switch (routeData->mRouteType) + { + case RouteData::ProtocolRoute: + { + RouteDataForProtocol* proto = (RouteDataForProtocol*) routeData; + ALOGD ("%s: ee h=0x%X; protocol=0x%X", fn, proto->mNfaEeHandle, proto->mProtocol); + } + break; + } + } + + ALOGD ("%s: sec elem route database", fn); + db = getDatabase (SecElemRouteDatabase); + for (Database::iterator iter2 = db->begin(); iter2 != db->end(); iter2++) + { + RouteData* routeData = *iter2; + switch (routeData->mRouteType) + { + case RouteData::ProtocolRoute: + { + RouteDataForProtocol* proto = (RouteDataForProtocol*) routeData; + ALOGD ("%s: ee h=0x%X; protocol=0x%X", fn, proto->mNfaEeHandle, proto->mProtocol); + } + break; + case RouteData::TechnologyRoute: + { + RouteDataForTechnology* tech = (RouteDataForTechnology*) routeData; + ALOGD ("%s: ee h=0x%X; technology=0x%X", fn, tech->mNfaEeHandle, tech->mTechnology); + } + break; + } + } +} diff --git a/nci/jni/RouteDataSet.h b/nci/jni/RouteDataSet.h new file mode 100644 index 0000000..d2a09b8 --- /dev/null +++ b/nci/jni/RouteDataSet.h @@ -0,0 +1,308 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Import and export general routing data using a XML file. + */ +#pragma once +#include "NfcJniUtil.h" +#include "nfa_api.h" +#include +#include +#include + + +/***************************************************************************** +** +** Name: RouteData +** +** Description: Base class for every kind of route data. +** +*****************************************************************************/ +class RouteData +{ +public: + enum RouteType {ProtocolRoute, TechnologyRoute}; + RouteType mRouteType; + +protected: + RouteData (RouteType routeType) : mRouteType (routeType) + {} +}; + + + + +/***************************************************************************** +** +** Name: RouteDataForProtocol +** +** Description: Data for protocol routes. +** +*****************************************************************************/ +class RouteDataForProtocol : public RouteData +{ +public: + int mNfaEeHandle; //for example 0x4f3, 0x4f4 + bool mSwitchOn; + bool mSwitchOff; + bool mBatteryOff; + tNFA_PROTOCOL_MASK mProtocol; + + RouteDataForProtocol () : RouteData (ProtocolRoute), mNfaEeHandle (NFA_HANDLE_INVALID), + mSwitchOn (false), mSwitchOff (false), mBatteryOff (false), + mProtocol (0) + {} +}; + + +/***************************************************************************** +** +** Name: RouteDataForTechnology +** +** Description: Data for technology routes. +** +*****************************************************************************/ +class RouteDataForTechnology : public RouteData +{ +public: + int mNfaEeHandle; //for example 0x4f3, 0x4f4 + bool mSwitchOn; + bool mSwitchOff; + bool mBatteryOff; + tNFA_TECHNOLOGY_MASK mTechnology; + + RouteDataForTechnology () : RouteData (TechnologyRoute), mNfaEeHandle (NFA_HANDLE_INVALID), + mSwitchOn (false), mSwitchOff (false), mBatteryOff (false), + mTechnology (0) + {} +}; + + +/*****************************************************************************/ +/*****************************************************************************/ + + +/***************************************************************************** +** +** Name: AidBuffer +** +** Description: Buffer to store AID after converting a string of hex +** values to bytes. +** +*****************************************************************************/ +class AidBuffer +{ +public: + + /******************************************************************************* + ** + ** Function: AidBuffer + ** + ** Description: Parse a string of hex numbers. Store result in an array of + ** bytes. + ** aid: string of hex numbers. + ** + ** Returns: None. + ** + *******************************************************************************/ + AidBuffer (std::string& aid); + + + /******************************************************************************* + ** + ** Function: ~AidBuffer + ** + ** Description: Release all resources. + ** + ** Returns: None. + ** + *******************************************************************************/ + ~AidBuffer (); + + + UINT8* buffer () {return mBuffer;}; + int length () {return mBufferLen;}; + +private: + UINT8* mBuffer; + UINT32 mBufferLen; +}; + + +/*****************************************************************************/ +/*****************************************************************************/ + + +/***************************************************************************** +** +** Name: RouteDataSet +** +** Description: Import and export general routing data using a XML file. +** See /data/bcm/param/route.xml +** +*****************************************************************************/ +class RouteDataSet +{ +public: + typedef std::vector Database; + enum DatabaseSelection {DefaultRouteDatabase, SecElemRouteDatabase}; + + + /******************************************************************************* + ** + ** Function: ~RouteDataSet + ** + ** Description: Release all resources. + ** + ** Returns: None. + ** + *******************************************************************************/ + ~RouteDataSet (); + + + /******************************************************************************* + ** + ** Function: initialize + ** + ** Description: Initialize resources. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool initialize (); + + + /******************************************************************************* + ** + ** Function: import + ** + ** Description: Import data from an XML file. Fill the database. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool import (); + + + /******************************************************************************* + ** + ** Function: getDatabase + ** + ** Description: Obtain a database of routing data. + ** selection: which database. + ** + ** Returns: Pointer to database. + ** + *******************************************************************************/ + Database* getDatabase (DatabaseSelection selection); + + + /******************************************************************************* + ** + ** Function: saveToFile + ** + ** Description: Save XML data from a string into a file. + ** routesXml: XML that represents routes. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + static bool saveToFile (const char* routesXml); + + + /******************************************************************************* + ** + ** Function: loadFromFile + ** + ** Description: Load XML data from file into a string. + ** routesXml: string to receive XML data. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + static bool loadFromFile (std::string& routesXml); + + + /******************************************************************************* + ** + ** Function: deleteFile + ** + ** Description: Delete route data XML file. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + static bool deleteFile (); + + /******************************************************************************* + ** + ** Function: printDiagnostic + ** + ** Description: Print some diagnostic output. + ** + ** Returns: None. + ** + *******************************************************************************/ + void printDiagnostic (); + +private: + Database mSecElemRouteDatabase; //routes when NFC service selects sec elem + Database mDefaultRouteDatabase; //routes when NFC service deselects sec elem + static const char* sConfigFile; + static const bool sDebug = false; + + + /******************************************************************************* + ** + ** Function: deleteDatabase + ** + ** Description: Delete all routes stored in all databases. + ** + ** Returns: None. + ** + *******************************************************************************/ + void deleteDatabase (); + + + /******************************************************************************* + ** + ** Function: importProtocolRoute + ** + ** Description: Parse data for protocol routes. + ** element: XML node for one protocol route. + ** database: store data in this database. + ** + ** Returns: None. + ** + *******************************************************************************/ + void importProtocolRoute (xmlNodePtr& element, Database& database); + + + /******************************************************************************* + ** + ** Function: importTechnologyRoute + ** + ** Description: Parse data for technology routes. + ** element: XML node for one technology route. + ** database: store data in this database. + ** + ** Returns: None. + ** + *******************************************************************************/ + void importTechnologyRoute (xmlNodePtr& element, Database& database); +}; + diff --git a/nci/jni/SecureElement.cpp b/nci/jni/SecureElement.cpp new file mode 100755 index 0000000..3c9256b --- /dev/null +++ b/nci/jni/SecureElement.cpp @@ -0,0 +1,2189 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Communicate with secure elements that are attached to the NFC + * controller. + */ +#include +#include +#include "OverrideLog.h" +#include "SecureElement.h" +#include "config.h" +#include "PowerSwitch.h" +#include "HostAidRouter.h" +#include "JavaClassConstants.h" + + +/***************************************************************************** +** +** public variables +** +*****************************************************************************/ +int gSEId = -1; // secure element ID to use in connectEE(), -1 means not set +int gGatePipe = -1; // gate id or static pipe id to use in connectEE(), -1 means not set +bool gUseStaticPipe = false; // if true, use gGatePipe as static pipe id. if false, use as gate id + +namespace android +{ + extern void startRfDiscovery (bool isStart); +} + +////////////////////////////////////////////// +////////////////////////////////////////////// + + +SecureElement SecureElement::sSecElem; +const char* SecureElement::APP_NAME = "nfc_jni"; + + +/******************************************************************************* +** +** Function: SecureElement +** +** Description: Initialize member variables. +** +** Returns: None +** +*******************************************************************************/ +SecureElement::SecureElement () +: mActiveEeHandle (NFA_HANDLE_INVALID), + mDestinationGate (4), //loopback gate + mNfaHciHandle (NFA_HANDLE_INVALID), + mNativeData (NULL), + mIsInit (false), + mActualNumEe (0), + mNumEePresent(0), + mbNewEE (true), // by default we start w/thinking there are new EE + mNewPipeId (0), + mNewSourceGate (0), + mActiveSeOverride(0), + mCommandStatus (NFA_STATUS_OK), + mIsPiping (false), + mCurrentRouteSelection (NoRoute), + mActualResponseSize(0), + mUseOberthurWarmReset (false), + mActivatedInListenMode (false), + mOberthurWarmResetCommand (3), + mRfFieldIsOn(false) +{ + memset (&mEeInfo, 0, sizeof(mEeInfo)); + memset (&mUiccInfo, 0, sizeof(mUiccInfo)); + memset (&mHciCfg, 0, sizeof(mHciCfg)); + memset (mResponseData, 0, sizeof(mResponseData)); + memset (mAidForEmptySelect, 0, sizeof(mAidForEmptySelect)); + memset (&mLastRfFieldToggle, 0, sizeof(mLastRfFieldToggle)); +} + + +/******************************************************************************* +** +** Function: ~SecureElement +** +** Description: Release all resources. +** +** Returns: None +** +*******************************************************************************/ +SecureElement::~SecureElement () +{ +} + + +/******************************************************************************* +** +** Function: getInstance +** +** Description: Get the SecureElement singleton object. +** +** Returns: SecureElement object. +** +*******************************************************************************/ +SecureElement& SecureElement::getInstance() +{ + return sSecElem; +} + + +/******************************************************************************* +** +** Function: setActiveSeOverride +** +** Description: Specify which secure element to turn on. +** activeSeOverride: ID of secure element +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::setActiveSeOverride(UINT8 activeSeOverride) +{ + ALOGD ("SecureElement::setActiveSeOverride, seid=0x%X", activeSeOverride); + mActiveSeOverride = activeSeOverride; +} + + +/******************************************************************************* +** +** Function: initialize +** +** Description: Initialize all member variables. +** native: Native data. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::initialize (nfc_jni_native_data* native) +{ + static const char fn [] = "SecureElement::initialize"; + tNFA_STATUS nfaStat; + UINT8 xx = 0, yy = 0; + unsigned long num = 0; + + ALOGD ("%s: enter", fn); + + if (GetNumValue("NFA_HCI_DEFAULT_DEST_GATE", &num, sizeof(num))) + mDestinationGate = num; + ALOGD ("%s: Default destination gate: %d", fn, mDestinationGate); + + // active SE, if not set active all SEs + if (GetNumValue("ACTIVE_SE", &num, sizeof(num))) + mActiveSeOverride = num; + ALOGD ("%s: Active SE override: %d", fn, mActiveSeOverride); + + if (GetNumValue("OBERTHUR_WARM_RESET_COMMAND", &num, sizeof(num))) + { + mUseOberthurWarmReset = true; + mOberthurWarmResetCommand = (UINT8) num; + } + + mActiveEeHandle = NFA_HANDLE_INVALID; + mNfaHciHandle = NFA_HANDLE_INVALID; + + mNativeData = native; + mActualNumEe = MAX_NUM_EE; + mbNewEE = true; + mNewPipeId = 0; + mNewSourceGate = 0; + mCurrentRouteSelection = NoRoute; + memset (mEeInfo, 0, sizeof(mEeInfo)); + memset (&mUiccInfo, 0, sizeof(mUiccInfo)); + memset (&mHciCfg, 0, sizeof(mHciCfg)); + mUsedAids.clear (); + memset(mAidForEmptySelect, 0, sizeof(mAidForEmptySelect)); + + // Get Fresh EE info. + if (! getEeInfo()) + return (false); + + { + SyncEventGuard guard (mEeRegisterEvent); + ALOGD ("%s: try ee register", fn); + nfaStat = NFA_EeRegister (nfaEeCallback); + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: fail ee register; error=0x%X", fn, nfaStat); + return (false); + } + mEeRegisterEvent.wait (); + } + + // If the controller has an HCI Network, register for that + for (xx = 0; xx < mActualNumEe; xx++) + { + if ((mEeInfo[xx].num_interface > 0) && (mEeInfo[xx].ee_interface[0] == NCI_NFCEE_INTERFACE_HCI_ACCESS) ) + { + ALOGD ("%s: Found HCI network, try hci register", fn); + + SyncEventGuard guard (mHciRegisterEvent); + + nfaStat = NFA_HciRegister (const_cast(APP_NAME), nfaHciCallback, TRUE); + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: fail hci register; error=0x%X", fn, nfaStat); + return (false); + } + mHciRegisterEvent.wait(); + break; + } + } + + mRouteDataSet.initialize (); + mRouteDataSet.import (); //read XML file + HostAidRouter::getInstance().initialize (); + + GetStrValue(NAME_AID_FOR_EMPTY_SELECT, (char*)&mAidForEmptySelect[0], sizeof(mAidForEmptySelect)); + + mIsInit = true; + ALOGD ("%s: exit", fn); + return (true); +} + + +/******************************************************************************* +** +** Function: finalize +** +** Description: Release all resources. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::finalize () +{ + static const char fn [] = "SecureElement::finalize"; + ALOGD ("%s: enter", fn); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + + NFA_EeDeregister (nfaEeCallback); + + if (mNfaHciHandle != NFA_HANDLE_INVALID) + NFA_HciDeregister (const_cast(APP_NAME)); + + mNfaHciHandle = NFA_HANDLE_INVALID; + mNativeData = NULL; + mIsInit = false; + mActualNumEe = 0; + mNumEePresent = 0; + mNewPipeId = 0; + mNewSourceGate = 0; + mIsPiping = false; + memset (mEeInfo, 0, sizeof(mEeInfo)); + memset (&mUiccInfo, 0, sizeof(mUiccInfo)); + + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: getEeInfo +** +** Description: Get latest information about execution environments from stack. +** +** Returns: True if at least 1 EE is available. +** +*******************************************************************************/ +bool SecureElement::getEeInfo() +{ + static const char fn [] = "SecureElement::getEeInfo"; + ALOGD ("%s: enter; mbNewEE=%d, mActualNumEe=%d", fn, mbNewEE, mActualNumEe); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + UINT8 xx = 0, yy = 0; + + // If mbNewEE is true then there is new EE info. + if (mbNewEE) + { + mActualNumEe = MAX_NUM_EE; + + if ((nfaStat = NFA_EeGetInfo (&mActualNumEe, mEeInfo)) != NFA_STATUS_OK) + { + ALOGE ("%s: fail get info; error=0x%X", fn, nfaStat); + mActualNumEe = 0; + } + else + { + mbNewEE = false; + + ALOGD ("%s: num EEs discovered: %u", fn, mActualNumEe); + if (mActualNumEe != 0) + { + for (UINT8 xx = 0; xx < mActualNumEe; xx++) + { + if ((mEeInfo[xx].num_interface != 0) && (mEeInfo[xx].ee_interface[0] != NCI_NFCEE_INTERFACE_HCI_ACCESS) ) + mNumEePresent++; + + ALOGD ("%s: EE[%u] Handle: 0x%04x Status: %s Num I/f: %u: (0x%02x, 0x%02x) Num TLVs: %u", + fn, xx, mEeInfo[xx].ee_handle, eeStatusToString(mEeInfo[xx].ee_status), mEeInfo[xx].num_interface, + mEeInfo[xx].ee_interface[0], mEeInfo[xx].ee_interface[1], mEeInfo[xx].num_tlvs); + + for (yy = 0; yy < mEeInfo[xx].num_tlvs; yy++) + { + ALOGD ("%s: EE[%u] TLV[%u] Tag: 0x%02x Len: %u Values[]: 0x%02x 0x%02x 0x%02x ...", + fn, xx, yy, mEeInfo[xx].ee_tlv[yy].tag, mEeInfo[xx].ee_tlv[yy].len, mEeInfo[xx].ee_tlv[yy].info[0], + mEeInfo[xx].ee_tlv[yy].info[1], mEeInfo[xx].ee_tlv[yy].info[2]); + } + } + } + } + } + ALOGD ("%s: exit; mActualNumEe=%d, mNumEePresent=%d", fn, mActualNumEe,mNumEePresent); + return (mActualNumEe != 0); +} + + +/******************************************************************************* +** +** Function TimeDiff +** +** Description Computes time difference in milliseconds. +** +** Returns Time difference in milliseconds +** +*******************************************************************************/ +static UINT32 TimeDiff(timespec start, timespec end) +{ + end.tv_sec -= start.tv_sec; + end.tv_nsec -= start.tv_nsec; + + if (end.tv_nsec < 0) { + end.tv_nsec += 10e8; + end.tv_sec -=1; + } + + return (end.tv_sec * 1000) + (end.tv_nsec / 10e5); +} + +/******************************************************************************* +** +** Function: isRfFieldOn +** +** Description: Can be used to determine if the SE is in an RF field +** +** Returns: True if the SE is activated in an RF field +** +*******************************************************************************/ +bool SecureElement::isRfFieldOn() { + AutoMutex mutex(mMutex); + if (mRfFieldIsOn) { + return true; + } + struct timespec now; + int ret = clock_gettime(CLOCK_MONOTONIC, &now); + if (ret == -1) { + ALOGE("isRfFieldOn(): clock_gettime failed"); + return false; + } + if (TimeDiff(mLastRfFieldToggle, now) < 50) { + // If it was less than 50ms ago that RF field + // was turned off, still return ON. + return true; + } else { + return false; + } +} + +/******************************************************************************* +** +** Function: isActivatedInListenMode +** +** Description: Can be used to determine if the SE is activated in listen mode +** +** Returns: True if the SE is activated in listen mode +** +*******************************************************************************/ +bool SecureElement::isActivatedInListenMode() { + return mActivatedInListenMode; +} + +/******************************************************************************* +** +** Function: getListOfEeHandles +** +** Description: Get the list of handles of all execution environments. +** e: Java Virtual Machine. +** +** Returns: List of handles of all execution environments. +** +*******************************************************************************/ +jintArray SecureElement::getListOfEeHandles (JNIEnv* e) +{ + static const char fn [] = "SecureElement::getListOfEeHandles"; + ALOGD ("%s: enter", fn); + if (mNumEePresent == 0) + return NULL; + jintArray list = NULL; + + if (!mIsInit) + { + ALOGE ("%s: not init", fn); + return (NULL); + } + + // Get Fresh EE info. + if (! getEeInfo()) + return (NULL); + + list = e->NewIntArray (mNumEePresent); //allocate array + jint jj = 0; + int cnt = 0; + for (int ii = 0; ii < mActualNumEe && cnt < mNumEePresent; ii++) + { + ALOGD ("%s: %u = 0x%X", fn, ii, mEeInfo[ii].ee_handle); + if ((mEeInfo[ii].num_interface == 0) || (mEeInfo[ii].ee_interface[0] == NCI_NFCEE_INTERFACE_HCI_ACCESS) ) + { + continue; + } + + jj = mEeInfo[ii].ee_handle & ~NFA_HANDLE_GROUP_EE; + e->SetIntArrayRegion (list, cnt++, 1, &jj); + } + //e->DeleteLocalRef (list); + + ALOGD("%s: exit", fn); + return list; +} + + +/******************************************************************************* +** +** Function: activate +** +** Description: Turn on the secure element. +** seID: ID of secure element. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::activate (jint seID) +{ + static const char fn [] = "SecureElement::activate"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + int numActivatedEe = 0; + + ALOGD ("%s: enter; seID=0x%X", fn, seID); + + if (!mIsInit) + { + ALOGE ("%s: not init", fn); + return false; + } + + if (mActiveEeHandle != NFA_HANDLE_INVALID) + { + ALOGD ("%s: already active", fn); + return true; + } + + // Get Fresh EE info if needed. + if (! getEeInfo()) + { + ALOGE ("%s: no EE info", fn); + return false; + } + + mActiveEeHandle = getDefaultEeHandle(); + ALOGD ("%s: active ee h=0x%X, override se=0x%X", fn, mActiveEeHandle, mActiveSeOverride); + if (mActiveEeHandle == NFA_HANDLE_INVALID) + { + ALOGE ("%s: ee not found", fn); + return false; + } + + UINT16 override_se = 0; + if (mActiveSeOverride) + override_se = NFA_HANDLE_GROUP_EE | mActiveSeOverride; + + if (mRfFieldIsOn) { + ALOGE("%s: RF field indication still on, resetting", fn); + mRfFieldIsOn = false; + } + + ALOGD ("%s: override seid=0x%X", fn, override_se ); + //activate every discovered secure element + for (int index=0; index < mActualNumEe; index++) + { + tNFA_EE_INFO& eeItem = mEeInfo[index]; + + if ((eeItem.ee_handle == EE_HANDLE_0xF3) || (eeItem.ee_handle == EE_HANDLE_0xF4)) + { + if (override_se && (override_se != eeItem.ee_handle) ) + continue; // do not enable all SEs; only the override one + + if (eeItem.ee_status != NFC_NFCEE_STATUS_INACTIVE) + { + ALOGD ("%s: h=0x%X already activated", fn, eeItem.ee_handle); + numActivatedEe++; + continue; + } + + { + SyncEventGuard guard (mEeSetModeEvent); + ALOGD ("%s: set EE mode activate; h=0x%X", fn, eeItem.ee_handle); + if ((nfaStat = NFA_EeModeSet (eeItem.ee_handle, NFA_EE_MD_ACTIVATE)) == NFA_STATUS_OK) + { + mEeSetModeEvent.wait (); //wait for NFA_EE_MODE_SET_EVT + if (eeItem.ee_status == NFC_NFCEE_STATUS_ACTIVE) + numActivatedEe++; + } + else + ALOGE ("%s: NFA_EeModeSet failed; error=0x%X", fn, nfaStat); + } + } + } //for + + for (UINT8 xx = 0; xx < mActualNumEe; xx++) + { + if ((mEeInfo[xx].num_interface != 0) && (mEeInfo[xx].ee_interface[0] != NCI_NFCEE_INTERFACE_HCI_ACCESS) && + (mEeInfo[xx].ee_status != NFC_NFCEE_STATUS_INACTIVE)) + { + mActiveEeHandle = mEeInfo[xx].ee_handle; + break; + } + } + + ALOGD ("%s: exit; ok=%u", fn, numActivatedEe > 0); + return numActivatedEe > 0; +} + + +/******************************************************************************* +** +** Function: deactivate +** +** Description: Turn off the secure element. +** seID: ID of secure element. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::deactivate (jint seID) +{ + static const char fn [] = "SecureElement::deactivate"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + int numDeactivatedEe = 0; + bool retval = false; + + ALOGD ("%s: enter; seID=0x%X, mActiveEeHandle=0x%X", fn, seID, mActiveEeHandle); + + if (!mIsInit) + { + ALOGE ("%s: not init", fn); + goto TheEnd; + } + + //if the controller is routing to sec elems or piping, + //then the secure element cannot be deactivated + if ((mCurrentRouteSelection == SecElemRoute) || mIsPiping) + { + ALOGE ("%s: still busy", fn); + goto TheEnd; + } + + if (mActiveEeHandle == NFA_HANDLE_INVALID) + { + ALOGE ("%s: invalid EE handle", fn); + goto TheEnd; + } + + mActiveEeHandle = NFA_HANDLE_INVALID; + retval = true; + +TheEnd: + ALOGD ("%s: exit; ok=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: notifyTransactionListenersOfAid +** +** Description: Notify the NFC service about a transaction event from secure element. +** aid: Buffer contains application ID. +** aidLen: Length of application ID. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::notifyTransactionListenersOfAid (const UINT8* aidBuffer, UINT8 aidBufferLen) +{ + static const char fn [] = "SecureElement::notifyTransactionListenersOfAid"; + ALOGD ("%s: enter; aid len=%u", fn, aidBufferLen); + + if (aidBufferLen == 0) + return; + + jobject tlvJavaArray = NULL; + JNIEnv* e = NULL; + UINT8* tlv = 0; + const UINT16 tlvMaxLen = aidBufferLen + 10; + UINT16 tlvActualLen = 0; + bool stat = false; + + mNativeData->vm->AttachCurrentThread (&e, NULL); + if (e == NULL) + { + ALOGE ("%s: jni env is null", fn); + return; + } + + tlv = new UINT8 [tlvMaxLen]; + if (tlv == NULL) + { + ALOGE ("%s: fail allocate tlv", fn); + goto TheEnd; + } + + memcpy (tlv, aidBuffer, aidBufferLen); + tlvActualLen = aidBufferLen; + + tlvJavaArray = e->NewByteArray (tlvActualLen); + if (tlvJavaArray == NULL) + { + ALOGE ("%s: fail allocate array", fn); + goto TheEnd; + } + + e->SetByteArrayRegion ((jbyteArray)tlvJavaArray, 0, tlvActualLen, (jbyte *)tlv); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail fill array", fn); + goto TheEnd; + } + + e->CallVoidMethod (mNativeData->manager, android::gCachedNfcManagerNotifyTransactionListeners, tlvJavaArray); + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail notify", fn); + goto TheEnd; + } + +TheEnd: + if (tlvJavaArray) + e->DeleteLocalRef (tlvJavaArray); + mNativeData->vm->DetachCurrentThread (); + delete [] tlv; + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: connectEE +** +** Description: Connect to the execution environment. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::connectEE () +{ + static const char fn [] = "SecureElement::connectEE"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + bool retVal = false; + UINT8 destHost = 0; + unsigned long num = 0; + char pipeConfName[40]; + tNFA_HANDLE eeHandle = mActiveEeHandle; + + ALOGD ("%s: enter, mActiveEeHandle: 0x%04x, SEID: 0x%x, pipe_gate_num=%d, use pipe=%d", + fn, mActiveEeHandle, gSEId, gGatePipe, gUseStaticPipe); + + if (!mIsInit) + { + ALOGE ("%s: not init", fn); + return (false); + } + + if (gSEId != -1) + { + eeHandle = gSEId | NFA_HANDLE_GROUP_EE; + ALOGD ("%s: Using SEID: 0x%x", fn, eeHandle ); + } + + if (eeHandle == NFA_HANDLE_INVALID) + { + ALOGE ("%s: invalid handle 0x%X", fn, eeHandle); + return (false); + } + + tNFA_EE_INFO *pEE = findEeByHandle (eeHandle); + + if (pEE == NULL) + { + ALOGE ("%s: Handle 0x%04x NOT FOUND !!", fn, eeHandle); + return (false); + } + + // Disable RF discovery completely while the DH is connected + android::startRfDiscovery(false); + + mNewSourceGate = 0; + + if (gGatePipe == -1) + { + // pipe/gate num was not specifed by app, get from config file + mNewPipeId = 0; + + // Construct the PIPE name based on the EE handle (e.g. NFA_HCI_STATIC_PIPE_ID_F3 for UICC0). + snprintf (pipeConfName, sizeof(pipeConfName), "NFA_HCI_STATIC_PIPE_ID_%02X", eeHandle & NFA_HANDLE_MASK); + + if (GetNumValue(pipeConfName, &num, sizeof(num)) && (num != 0)) + { + mNewPipeId = num; + ALOGD ("%s: Using static pipe id: 0x%X", __FUNCTION__, mNewPipeId); + } + else + { + ALOGD ("%s: Did not find value '%s' defined in the .conf", __FUNCTION__, pipeConfName); + } + } + else + { + if (gUseStaticPipe) + { + mNewPipeId = gGatePipe; + } + else + { + mNewPipeId = 0; + mDestinationGate= gGatePipe; + } + } + + // If the .conf file had a static pipe to use, just use it. + if (mNewPipeId != 0) + { + UINT8 host = (mNewPipeId == STATIC_PIPE_0x70) ? 0x02 : 0x03; + UINT8 gate = (mNewPipeId == STATIC_PIPE_0x70) ? 0xF0 : 0xF1; + nfaStat = NFA_HciAddStaticPipe(mNfaHciHandle, host, gate, mNewPipeId); + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: fail create static pipe; error=0x%X", fn, nfaStat); + retVal = false; + goto TheEnd; + } + } + else + { + if ( (pEE->num_tlvs >= 1) && (pEE->ee_tlv[0].tag == NFA_EE_TAG_HCI_HOST_ID) ) + destHost = pEE->ee_tlv[0].info[0]; + else + destHost = 2; + + // Get a list of existing gates and pipes + { + ALOGD ("%s: get gate, pipe list", fn); + SyncEventGuard guard (mPipeListEvent); + nfaStat = NFA_HciGetGateAndPipeList (mNfaHciHandle); + if (nfaStat == NFA_STATUS_OK) + { + mPipeListEvent.wait(); + if (mHciCfg.status == NFA_STATUS_OK) + { + for (UINT8 xx = 0; xx < mHciCfg.num_pipes; xx++) + { + if ( (mHciCfg.pipe[xx].dest_host == destHost) + && (mHciCfg.pipe[xx].dest_gate == mDestinationGate) ) + { + mNewSourceGate = mHciCfg.pipe[xx].local_gate; + mNewPipeId = mHciCfg.pipe[xx].pipe_id; + + ALOGD ("%s: found configured gate: 0x%02x pipe: 0x%02x", fn, mNewSourceGate, mNewPipeId); + break; + } + } + } + } + } + + if (mNewSourceGate == 0) + { + ALOGD ("%s: allocate gate", fn); + //allocate a source gate and store in mNewSourceGate + SyncEventGuard guard (mAllocateGateEvent); + if ((nfaStat = NFA_HciAllocGate (mNfaHciHandle)) != NFA_STATUS_OK) + { + ALOGE ("%s: fail allocate source gate; error=0x%X", fn, nfaStat); + goto TheEnd; + } + mAllocateGateEvent.wait (); + if (mCommandStatus != NFA_STATUS_OK) + goto TheEnd; + } + + if (mNewPipeId == 0) + { + ALOGD ("%s: create pipe", fn); + SyncEventGuard guard (mCreatePipeEvent); + nfaStat = NFA_HciCreatePipe (mNfaHciHandle, mNewSourceGate, destHost, mDestinationGate); + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: fail create pipe; error=0x%X", fn, nfaStat); + goto TheEnd; + } + mCreatePipeEvent.wait (); + if (mCommandStatus != NFA_STATUS_OK) + goto TheEnd; + } + + { + ALOGD ("%s: open pipe", fn); + SyncEventGuard guard (mPipeOpenedEvent); + nfaStat = NFA_HciOpenPipe (mNfaHciHandle, mNewPipeId); + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: fail open pipe; error=0x%X", fn, nfaStat); + goto TheEnd; + } + mPipeOpenedEvent.wait (); + if (mCommandStatus != NFA_STATUS_OK) + goto TheEnd; + } + } + + retVal = true; + +TheEnd: + mIsPiping = retVal; + if (!retVal) + { + // if open failed we need to de-allocate the gate + disconnectEE(0); + } + + ALOGD ("%s: exit; ok=%u", fn, retVal); + return retVal; +} + + +/******************************************************************************* +** +** Function: disconnectEE +** +** Description: Disconnect from the execution environment. +** seID: ID of secure element. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::disconnectEE (jint seID) +{ + static const char fn [] = "SecureElement::disconnectEE"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + tNFA_HANDLE eeHandle = seID; + + ALOGD("%s: seID=0x%X; handle=0x%04x", fn, seID, eeHandle); + + if (mUseOberthurWarmReset) + { + //send warm-reset command to Oberthur secure element which deselects the applet; + //this is an Oberthur-specific command; + ALOGD("%s: try warm-reset on pipe id 0x%X; cmd=0x%X", fn, mNewPipeId, mOberthurWarmResetCommand); + SyncEventGuard guard (mRegistryEvent); + nfaStat = NFA_HciSetRegistry (mNfaHciHandle, mNewPipeId, + 1, 1, &mOberthurWarmResetCommand); + if (nfaStat == NFA_STATUS_OK) + { + mRegistryEvent.wait (); + ALOGD("%s: completed warm-reset on pipe 0x%X", fn, mNewPipeId); + } + } + + if (mNewSourceGate) + { + SyncEventGuard guard (mDeallocateGateEvent); + if ((nfaStat = NFA_HciDeallocGate (mNfaHciHandle, mNewSourceGate)) == NFA_STATUS_OK) + mDeallocateGateEvent.wait (); + else + ALOGE ("%s: fail dealloc gate; error=0x%X", fn, nfaStat); + } + mIsPiping = false; + // Re-enable RF discovery + // Note that it only effactuates the current configuration, + // so if polling/listening were configured OFF (forex because + // the screen was off), they will stay OFF with this call. + android::startRfDiscovery(true); + return true; +} + + +/******************************************************************************* +** +** Function: transceive +** +** Description: Send data to the secure element; read it's response. +** xmitBuffer: Data to transmit. +** xmitBufferSize: Length of data. +** recvBuffer: Buffer to receive response. +** recvBufferMaxSize: Maximum size of buffer. +** recvBufferActualSize: Actual length of response. +** timeoutMillisec: timeout in millisecond. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::transceive (UINT8* xmitBuffer, INT32 xmitBufferSize, UINT8* recvBuffer, + INT32 recvBufferMaxSize, INT32& recvBufferActualSize, INT32 timeoutMillisec) +{ + static const char fn [] = "SecureElement::transceive"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + bool isSuccess = false; + bool waitOk = false; + UINT8 newSelectCmd[NCI_MAX_AID_LEN + 10]; + + ALOGD ("%s: enter; xmitBufferSize=%ld; recvBufferMaxSize=%ld; timeout=%ld", fn, xmitBufferSize, recvBufferMaxSize, timeoutMillisec); + + // Check if we need to replace an "empty" SELECT command. + // 1. Has there been a AID configured, and + // 2. Is that AID a valid length (i.e 16 bytes max), and + // 3. Is the APDU at least 4 bytes (for header), and + // 4. Is INS == 0xA4 (SELECT command), and + // 5. Is P1 == 0x04 (SELECT by AID), and + // 6. Is the APDU len 4 or 5 bytes. + // + // Note, the length of the configured AID is in the first + // byte, and AID starts from the 2nd byte. + if (mAidForEmptySelect[0] // 1 + && (mAidForEmptySelect[0] <= NCI_MAX_AID_LEN) // 2 + && (xmitBufferSize >= 4) // 3 + && (xmitBuffer[1] == 0xA4) // 4 + && (xmitBuffer[2] == 0x04) // 5 + && (xmitBufferSize <= 5)) // 6 + { + UINT8 idx = 0; + + // Copy APDU command header from the input buffer. + memcpy(&newSelectCmd[0], &xmitBuffer[0], 4); + idx = 4; + + // Set the Lc value to length of the new AID + newSelectCmd[idx++] = mAidForEmptySelect[0]; + + // Copy the AID + memcpy(&newSelectCmd[idx], &mAidForEmptySelect[1], mAidForEmptySelect[0]); + idx += mAidForEmptySelect[0]; + + // If there is an Le (5th byte of APDU), add it to the end. + if (xmitBufferSize == 5) + newSelectCmd[idx++] = xmitBuffer[4]; + + // Point to the new APDU + xmitBuffer = &newSelectCmd[0]; + xmitBufferSize = idx; + + ALOGD ("%s: Empty AID SELECT cmd detected, substituting AID from config file, new length=%d", fn, idx); + } + + { + SyncEventGuard guard (mTransceiveEvent); + mActualResponseSize = 0; + memset (mResponseData, 0, sizeof(mResponseData)); + if ((mNewPipeId == STATIC_PIPE_0x70) || (mNewPipeId == STATIC_PIPE_0x71)) + nfaStat = NFA_HciSendEvent (mNfaHciHandle, mNewPipeId, EVT_SEND_DATA, xmitBufferSize, xmitBuffer, sizeof(mResponseData), mResponseData, 0); + else + nfaStat = NFA_HciSendEvent (mNfaHciHandle, mNewPipeId, NFA_HCI_EVT_POST_DATA, xmitBufferSize, xmitBuffer, sizeof(mResponseData), mResponseData, 0); + + if (nfaStat == NFA_STATUS_OK) + { + waitOk = mTransceiveEvent.wait (timeoutMillisec); + if (waitOk == false) //timeout occurs + { + ALOGE ("%s: wait response timeout", fn); + goto TheEnd; + } + } + else + { + ALOGE ("%s: fail send data; error=0x%X", fn, nfaStat); + goto TheEnd; + } + } + + if (mActualResponseSize > recvBufferMaxSize) + recvBufferActualSize = recvBufferMaxSize; + else + recvBufferActualSize = mActualResponseSize; + + memcpy (recvBuffer, mResponseData, recvBufferActualSize); + isSuccess = true; + +TheEnd: + ALOGD ("%s: exit; isSuccess: %d; recvBufferActualSize: %ld", fn, isSuccess, recvBufferActualSize); + return (isSuccess); +} + + +/******************************************************************************* +** +** Function: notifyListenModeState +** +** Description: Notify the NFC service about whether the SE was activated +** in listen mode. +** isActive: Whether the secure element is activated. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::notifyListenModeState (bool isActivated) { + static const char fn [] = "SecureElement::notifyListenMode"; + JNIEnv *e = NULL; + + ALOGD ("%s: enter; listen mode active=%u", fn, isActivated); + mNativeData->vm->AttachCurrentThread (&e, NULL); + + if (e == NULL) + { + ALOGE ("%s: jni env is null", fn); + return; + } + + mActivatedInListenMode = isActivated; + if (isActivated) { + e->CallVoidMethod (mNativeData->manager, android::gCachedNfcManagerNotifySeListenActivated); + } + else { + e->CallVoidMethod (mNativeData->manager, android::gCachedNfcManagerNotifySeListenDeactivated); + } + + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail notify", fn); + } + + mNativeData->vm->DetachCurrentThread (); + ALOGD ("%s: exit", fn); +} + +/******************************************************************************* +** +** Function: notifyRfFieldEvent +** +** Description: Notify the NFC service about RF field events from the stack. +** isActive: Whether any secure element is activated. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::notifyRfFieldEvent (bool isActive) +{ + static const char fn [] = "SecureElement::notifyRfFieldEvent"; + JNIEnv *e = NULL; + + ALOGD ("%s: enter; is active=%u", fn, isActive); + mNativeData->vm->AttachCurrentThread (&e, NULL); + + if (e == NULL) + { + ALOGE ("%s: jni env is null", fn); + return; + } + + mMutex.lock(); + int ret = clock_gettime (CLOCK_MONOTONIC, &mLastRfFieldToggle); + if (ret == -1) { + ALOGE("%s: clock_gettime failed", fn); + // There is no good choice here... + } + if (isActive) { + mRfFieldIsOn = true; + e->CallVoidMethod (mNativeData->manager, android::gCachedNfcManagerNotifySeFieldActivated); + } + else { + mRfFieldIsOn = false; + e->CallVoidMethod (mNativeData->manager, android::gCachedNfcManagerNotifySeFieldDeactivated); + } + mMutex.unlock(); + + if (e->ExceptionCheck()) + { + e->ExceptionClear(); + ALOGE ("%s: fail notify", fn); + } + mNativeData->vm->DetachCurrentThread (); + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: storeUiccInfo +** +** Description: Store a copy of the execution environment information from the stack. +** info: execution environment information. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::storeUiccInfo (tNFA_EE_DISCOVER_REQ& info) +{ + static const char fn [] = "SecureElement::storeUiccInfo"; + ALOGD ("%s: Status: %u Num EE: %u", fn, info.status, info.num_ee); + + SyncEventGuard guard (mUiccInfoEvent); + memcpy (&mUiccInfo, &info, sizeof(mUiccInfo)); + for (UINT8 xx = 0; xx < info.num_ee; xx++) + { + //for each technology (A, B, F, B'), print the bit field that shows + //what protocol(s) is support by that technology + ALOGD ("%s EE[%u] Handle: 0x%04x techA: 0x%02x techB: 0x%02x techF: 0x%02x techBprime: 0x%02x", + fn, xx, info.ee_disc_info[xx].ee_handle, + info.ee_disc_info[xx].la_protocol, + info.ee_disc_info[xx].lb_protocol, + info.ee_disc_info[xx].lf_protocol, + info.ee_disc_info[xx].lbp_protocol); + } + mUiccInfoEvent.notifyOne (); +} + + +/******************************************************************************* +** +** Function: getUiccId +** +** Description: Get the ID of the secure element. +** eeHandle: Handle to the secure element. +** uid: Array to receive the ID. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::getUiccId (tNFA_HANDLE eeHandle, jbyteArray& uid) +{ + static const char fn [] = "SecureElement::getUiccId"; + ALOGD ("%s: ee h=0x%X", fn, eeHandle); + bool retval = false; + JNIEnv* e = NULL; + + mNativeData->vm->AttachCurrentThread (&e, NULL); + if (e == NULL) + { + ALOGE ("%s: jni env is null", fn); + return false; + } + + findUiccByHandle (eeHandle); + //cannot get UID from the stack; nothing to do + +TheEnd: + mNativeData->vm->DetachCurrentThread (); + ALOGD ("%s: exit; ret=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: getTechnologyList +** +** Description: Get all the technologies supported by a secure element. +** eeHandle: Handle of secure element. +** techList: List to receive the technologies. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::getTechnologyList (tNFA_HANDLE eeHandle, jintArray& techList) +{ + static const char fn [] = "SecureElement::getTechnologyList"; + ALOGD ("%s: ee h=0x%X", fn, eeHandle); + bool retval = false; + JNIEnv* e = NULL; + jint theList = 0; + + mNativeData->vm->AttachCurrentThread (&e, NULL); + if (e == NULL) + { + ALOGE ("%s: jni env is null", fn); + return false; + } + + tNFA_EE_DISCOVER_INFO *pUICC = findUiccByHandle (eeHandle); + + if (pUICC->la_protocol != 0) + theList = TARGET_TYPE_ISO14443_3A; + else if (pUICC->lb_protocol != 0) + theList = TARGET_TYPE_ISO14443_3B; + else if (pUICC->lf_protocol != 0) + theList = TARGET_TYPE_FELICA; + else if (pUICC->lbp_protocol != 0) + theList = TARGET_TYPE_ISO14443_3B; + else + theList = TARGET_TYPE_UNKNOWN; + +TheEnd: + mNativeData->vm->DetachCurrentThread (); + ALOGD ("%s: exit; ret=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: adjustRoutes +** +** Description: Adjust routes in the controller's listen-mode routing table. +** selection: which set of routes to configure the controller. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::adjustRoutes (RouteSelection selection) +{ + static const char fn [] = "SecureElement::adjustRoutes"; + ALOGD ("%s: enter; selection=%u", fn, selection); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + RouteDataSet::Database* db = mRouteDataSet.getDatabase (RouteDataSet::DefaultRouteDatabase); + + if (selection == SecElemRoute) + db = mRouteDataSet.getDatabase (RouteDataSet::SecElemRouteDatabase); + + mCurrentRouteSelection = selection; + adjustProtocolRoutes (db, selection); + adjustTechnologyRoutes (db, selection); + HostAidRouter::getInstance ().deleteAllRoutes (); //stop all AID routes to host + + if (db->empty()) + { + ALOGD ("%s: no route configuration", fn); + goto TheEnd; + } + + +TheEnd: + NFA_EeUpdateNow (); //apply new routes now + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: applyRoutes +** +** Description: Read route data from file and apply them again. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::applyRoutes () +{ + static const char fn [] = "SecureElement::applyRoutes"; + ALOGD ("%s: enter", fn); + if (mCurrentRouteSelection != NoRoute) + { + mRouteDataSet.import (); //read XML file + adjustRoutes (mCurrentRouteSelection); + } + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: adjustProtocolRoutes +** +** Description: Adjust default routing based on protocol in NFC listen mode. +** isRouteToEe: Whether routing to EE (true) or host (false). +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::adjustProtocolRoutes (RouteDataSet::Database* db, RouteSelection routeSelection) +{ + static const char fn [] = "SecureElement::adjustProtocolRoutes"; + ALOGD ("%s: enter", fn); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + const tNFA_PROTOCOL_MASK protoMask = NFA_PROTOCOL_MASK_ISO_DEP; + + /////////////////////// + // delete route to host + /////////////////////// + { + ALOGD ("%s: delete route to host", fn); + SyncEventGuard guard (mRoutingEvent); + if ((nfaStat = NFA_EeSetDefaultProtoRouting (NFA_EE_HANDLE_DH, 0, 0, 0)) == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail delete route to host; error=0x%X", fn, nfaStat); + } + + /////////////////////// + // delete route to every sec elem + /////////////////////// + for (int i=0; i < mActualNumEe; i++) + { + if ((mEeInfo[i].num_interface != 0) && + (mEeInfo[i].ee_interface[0] != NFC_NFCEE_INTERFACE_HCI_ACCESS) && + (mEeInfo[i].ee_status == NFA_EE_STATUS_ACTIVE)) + { + ALOGD ("%s: delete route to EE h=0x%X", fn, mEeInfo[i].ee_handle); + SyncEventGuard guard (mRoutingEvent); + if ((nfaStat = NFA_EeSetDefaultProtoRouting (mEeInfo[i].ee_handle, 0, 0, 0)) == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail delete route to EE; error=0x%X", fn, nfaStat); + } + } + + ////////////////////// + // configure route for every discovered sec elem + ////////////////////// + for (int i=0; i < mActualNumEe; i++) + { + //if sec elem is active + if ((mEeInfo[i].num_interface != 0) && + (mEeInfo[i].ee_interface[0] != NFC_NFCEE_INTERFACE_HCI_ACCESS) && + (mEeInfo[i].ee_status == NFA_EE_STATUS_ACTIVE)) + { + tNFA_PROTOCOL_MASK protocolsSwitchOn = 0; //all protocols that are active at full power + tNFA_PROTOCOL_MASK protocolsSwitchOff = 0; //all protocols that are active when phone is turned off + tNFA_PROTOCOL_MASK protocolsBatteryOff = 0; //all protocols that are active when there is no power + + //for every route in XML, look for protocol route; + //collect every protocol according to it's desired power mode + for (RouteDataSet::Database::iterator iter = db->begin(); iter != db->end(); iter++) + { + RouteData* routeData = *iter; + RouteDataForProtocol* route = NULL; + if (routeData->mRouteType != RouteData::ProtocolRoute) + continue; //skip other kinds of routing data + route = (RouteDataForProtocol*) (*iter); + if (route->mNfaEeHandle == mEeInfo[i].ee_handle) + { + if (route->mSwitchOn) + protocolsSwitchOn |= route->mProtocol; + if (route->mSwitchOff) + protocolsSwitchOff |= route->mProtocol; + if (route->mBatteryOff) + protocolsBatteryOff |= route->mProtocol; + } + } + + if (protocolsSwitchOn | protocolsSwitchOff | protocolsBatteryOff) + { + ALOGD ("%s: route to EE h=0x%X", fn, mEeInfo[i].ee_handle); + SyncEventGuard guard (mRoutingEvent); + nfaStat = NFA_EeSetDefaultProtoRouting (mEeInfo[i].ee_handle, + protocolsSwitchOn, protocolsSwitchOff, protocolsBatteryOff); + if (nfaStat == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail route to EE; error=0x%X", fn, nfaStat); + } + } //if sec elem is active + } //for every discovered sec elem + + ////////////////////// + // configure route to host + ////////////////////// + { + tNFA_PROTOCOL_MASK protocolsSwitchOn = 0; //all protocols that are active at full power + tNFA_PROTOCOL_MASK protocolsSwitchOff = 0; //all protocols that are active when phone is turned off + tNFA_PROTOCOL_MASK protocolsBatteryOff = 0; //all protocols that are active when there is no power + + //for every route in XML, look for protocol route; + //collect every protocol according to it's desired power mode + for (RouteDataSet::Database::iterator iter = db->begin(); iter != db->end(); iter++) + { + RouteData* routeData = *iter; + RouteDataForProtocol* route = NULL; + if (routeData->mRouteType != RouteData::ProtocolRoute) + continue; //skip other kinds of routing data + route = (RouteDataForProtocol*) (*iter); + if (route->mNfaEeHandle == NFA_EE_HANDLE_DH) + { + if (route->mSwitchOn) + protocolsSwitchOn |= route->mProtocol; + if (route->mSwitchOff) + protocolsSwitchOff |= route->mProtocol; + if (route->mBatteryOff) + protocolsBatteryOff |= route->mProtocol; + } + } + + if (protocolsSwitchOn | protocolsSwitchOff | protocolsBatteryOff) + { + ALOGD ("%s: route to EE h=0x%X", fn, NFA_EE_HANDLE_DH); + SyncEventGuard guard (mRoutingEvent); + nfaStat = NFA_EeSetDefaultProtoRouting (NFA_EE_HANDLE_DH, + protocolsSwitchOn, protocolsSwitchOff, protocolsBatteryOff); + if (nfaStat == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail route to EE; error=0x%X", fn, nfaStat); + } + } + + ////////////////////// + // if route database is empty, setup a default route + ////////////////////// + if (db->empty()) + { + tNFA_HANDLE eeHandle = NFA_EE_HANDLE_DH; + if (routeSelection == SecElemRoute) + eeHandle = getDefaultEeHandle (); + ALOGD ("%s: route to default EE h=0x%X", fn, eeHandle); + SyncEventGuard guard (mRoutingEvent); + nfaStat = NFA_EeSetDefaultProtoRouting (eeHandle, protoMask, 0, 0); + if (nfaStat == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail route to EE; error=0x%X", fn, nfaStat); + } + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: adjustTechnologyRoutes +** +** Description: Adjust default routing based on technology in NFC listen mode. +** isRouteToEe: Whether routing to EE (true) or host (false). +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::adjustTechnologyRoutes (RouteDataSet::Database* db, RouteSelection routeSelection) +{ + static const char fn [] = "SecureElement::adjustTechnologyRoutes"; + ALOGD ("%s: enter", fn); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + const tNFA_TECHNOLOGY_MASK techMask = NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B; + + /////////////////////// + // delete route to host + /////////////////////// + { + ALOGD ("%s: delete route to host", fn); + SyncEventGuard guard (mRoutingEvent); + if ((nfaStat = NFA_EeSetDefaultTechRouting (NFA_EE_HANDLE_DH, 0, 0, 0)) == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail delete route to host; error=0x%X", fn, nfaStat); + } + + /////////////////////// + // delete route to every sec elem + /////////////////////// + for (int i=0; i < mActualNumEe; i++) + { + if ((mEeInfo[i].num_interface != 0) && + (mEeInfo[i].ee_interface[0] != NFC_NFCEE_INTERFACE_HCI_ACCESS) && + (mEeInfo[i].ee_status == NFA_EE_STATUS_ACTIVE)) + { + ALOGD ("%s: delete route to EE h=0x%X", fn, mEeInfo[i].ee_handle); + SyncEventGuard guard (mRoutingEvent); + if ((nfaStat = NFA_EeSetDefaultTechRouting (mEeInfo[i].ee_handle, 0, 0, 0)) == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail delete route to EE; error=0x%X", fn, nfaStat); + } + } + + ////////////////////// + // configure route for every discovered sec elem + ////////////////////// + for (int i=0; i < mActualNumEe; i++) + { + //if sec elem is active + if ((mEeInfo[i].num_interface != 0) && + (mEeInfo[i].ee_interface[0] != NFC_NFCEE_INTERFACE_HCI_ACCESS) && + (mEeInfo[i].ee_status == NFA_EE_STATUS_ACTIVE)) + { + tNFA_TECHNOLOGY_MASK techsSwitchOn = 0; //all techs that are active at full power + tNFA_TECHNOLOGY_MASK techsSwitchOff = 0; //all techs that are active when phone is turned off + tNFA_TECHNOLOGY_MASK techsBatteryOff = 0; //all techs that are active when there is no power + + //for every route in XML, look for tech route; + //collect every tech according to it's desired power mode + for (RouteDataSet::Database::iterator iter = db->begin(); iter != db->end(); iter++) + { + RouteData* routeData = *iter; + RouteDataForTechnology* route = NULL; + if (routeData->mRouteType != RouteData::TechnologyRoute) + continue; //skip other kinds of routing data + route = (RouteDataForTechnology*) (*iter); + if (route->mNfaEeHandle == mEeInfo[i].ee_handle) + { + if (route->mSwitchOn) + techsSwitchOn |= route->mTechnology; + if (route->mSwitchOff) + techsSwitchOff |= route->mTechnology; + if (route->mBatteryOff) + techsBatteryOff |= route->mTechnology; + } + } + + if (techsSwitchOn | techsSwitchOff | techsBatteryOff) + { + ALOGD ("%s: route to EE h=0x%X", fn, mEeInfo[i].ee_handle); + SyncEventGuard guard (mRoutingEvent); + nfaStat = NFA_EeSetDefaultTechRouting (mEeInfo[i].ee_handle, + techsSwitchOn, techsSwitchOff, techsBatteryOff); + if (nfaStat == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail route to EE; error=0x%X", fn, nfaStat); + } + } //if sec elem is active + } //for every discovered sec elem + + ////////////////////// + // configure route to host + ////////////////////// + { + tNFA_TECHNOLOGY_MASK techsSwitchOn = 0; //all techs that are active at full power + tNFA_TECHNOLOGY_MASK techsSwitchOff = 0; //all techs that are active when phone is turned off + tNFA_TECHNOLOGY_MASK techsBatteryOff = 0; //all techs that are active when there is no power + + //for every route in XML, look for protocol route; + //collect every protocol according to it's desired power mode + for (RouteDataSet::Database::iterator iter = db->begin(); iter != db->end(); iter++) + { + RouteData* routeData = *iter; + RouteDataForTechnology * route = NULL; + if (routeData->mRouteType != RouteData::TechnologyRoute) + continue; //skip other kinds of routing data + route = (RouteDataForTechnology*) (*iter); + if (route->mNfaEeHandle == NFA_EE_HANDLE_DH) + { + if (route->mSwitchOn) + techsSwitchOn |= route->mTechnology; + if (route->mSwitchOff) + techsSwitchOff |= route->mTechnology; + if (route->mBatteryOff) + techsBatteryOff |= route->mTechnology; + } + } + + if (techsSwitchOn | techsSwitchOff | techsBatteryOff) + { + ALOGD ("%s: route to EE h=0x%X", fn, NFA_EE_HANDLE_DH); + SyncEventGuard guard (mRoutingEvent); + nfaStat = NFA_EeSetDefaultTechRouting (NFA_EE_HANDLE_DH, + techsSwitchOn, techsSwitchOff, techsBatteryOff); + if (nfaStat == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail route to EE; error=0x%X", fn, nfaStat); + } + } + + ////////////////////// + // if route database is empty, setup a default route + ////////////////////// + if (db->empty()) + { + tNFA_HANDLE eeHandle = NFA_EE_HANDLE_DH; + if (routeSelection == SecElemRoute) + eeHandle = getDefaultEeHandle (); + ALOGD ("%s: route to default EE h=0x%X", fn, eeHandle); + SyncEventGuard guard (mRoutingEvent); + nfaStat = NFA_EeSetDefaultTechRouting (eeHandle, techMask, 0, 0); + if (nfaStat == NFA_STATUS_OK) + mRoutingEvent.wait (); + else + ALOGE ("%s: fail route to EE; error=0x%X", fn, nfaStat); + } + ALOGD ("%s: exit", fn); +} + + +/******************************************************************************* +** +** Function: nfaEeCallback +** +** Description: Receive execution environment-related events from stack. +** event: Event code. +** eventData: Event data. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::nfaEeCallback (tNFA_EE_EVT event, tNFA_EE_CBACK_DATA* eventData) +{ + static const char fn [] = "SecureElement::nfaEeCallback"; + + switch (event) + { + case NFA_EE_REGISTER_EVT: + { + SyncEventGuard guard (sSecElem.mEeRegisterEvent); + ALOGD ("%s: NFA_EE_REGISTER_EVT; status=%u", fn, eventData->ee_register); + sSecElem.mEeRegisterEvent.notifyOne(); + } + break; + + case NFA_EE_MODE_SET_EVT: + { + ALOGD ("%s: NFA_EE_MODE_SET_EVT; status: 0x%04X handle: 0x%04X mActiveEeHandle: 0x%04X", fn, + eventData->mode_set.status, eventData->mode_set.ee_handle, sSecElem.mActiveEeHandle); + + if (eventData->mode_set.status == NFA_STATUS_OK) + { + tNFA_EE_INFO *pEE = sSecElem.findEeByHandle (eventData->mode_set.ee_handle); + if (pEE) + { + pEE->ee_status ^= 1; + ALOGD ("%s: NFA_EE_MODE_SET_EVT; pEE->ee_status: %s (0x%04x)", fn, SecureElement::eeStatusToString(pEE->ee_status), pEE->ee_status); + } + else + ALOGE ("%s: NFA_EE_MODE_SET_EVT; EE: 0x%04x not found. mActiveEeHandle: 0x%04x", fn, eventData->mode_set.ee_handle, sSecElem.mActiveEeHandle); + } + SyncEventGuard guard (sSecElem.mEeSetModeEvent); + sSecElem.mEeSetModeEvent.notifyOne(); + } + break; + + case NFA_EE_SET_TECH_CFG_EVT: + { + ALOGD ("%s: NFA_EE_SET_TECH_CFG_EVT; status=0x%X", fn, eventData->status); + SyncEventGuard guard (sSecElem.mRoutingEvent); + sSecElem.mRoutingEvent.notifyOne (); + } + break; + + case NFA_EE_SET_PROTO_CFG_EVT: + { + ALOGD ("%s: NFA_EE_SET_PROTO_CFG_EVT; status=0x%X", fn, eventData->status); + SyncEventGuard guard (sSecElem.mRoutingEvent); + sSecElem.mRoutingEvent.notifyOne (); + } + break; + + case NFA_EE_ACTION_EVT: + { + tNFA_EE_ACTION& action = eventData->action; + if (action.trigger == NFC_EE_TRIG_SELECT) + ALOGD ("%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=select (0x%X)", fn, action.ee_handle, action.trigger); + else if (action.trigger == NFC_EE_TRIG_APP_INIT) + { + tNFC_APP_INIT& app_init = action.param.app_init; + ALOGD ("%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=app-init (0x%X); aid len=%u; data len=%u", fn, + action.ee_handle, action.trigger, app_init.len_aid, app_init.len_data); + //if app-init operation is successful; + //app_init.data[] contains two bytes, which are the status codes of the event; + //app_init.data[] does not contain an APDU response; + //see EMV Contactless Specification for Payment Systems; Book B; Entry Point Specification; + //version 2.1; March 2011; section 3.3.3.5; + if ( (app_init.len_data > 1) && + (app_init.data[0] == 0x90) && + (app_init.data[1] == 0x00) ) + { + sSecElem.notifyTransactionListenersOfAid (app_init.aid, app_init.len_aid); + } + } + else if (action.trigger == NFC_EE_TRIG_RF_PROTOCOL) + ALOGD ("%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=rf protocol (0x%X)", fn, action.ee_handle, action.trigger); + else if (action.trigger == NFC_EE_TRIG_RF_TECHNOLOGY) + ALOGD ("%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=rf tech (0x%X)", fn, action.ee_handle, action.trigger); + else + ALOGE ("%s: NFA_EE_ACTION_EVT; h=0x%X; unknown trigger (0x%X)", fn, action.ee_handle, action.trigger); + } + break; + + case NFA_EE_DISCOVER_REQ_EVT: + ALOGD ("%s: NFA_EE_DISCOVER_REQ_EVT; status=0x%X; num ee=%u", __FUNCTION__, + eventData->discover_req.status, eventData->discover_req.num_ee); + sSecElem.storeUiccInfo (eventData->discover_req); + break; + + case NFA_EE_NO_CB_ERR_EVT: + ALOGD ("%s: NFA_EE_NO_CB_ERR_EVT status=%u", fn, eventData->status); + break; + + case NFA_EE_ADD_AID_EVT: + { + ALOGD ("%s: NFA_EE_ADD_AID_EVT status=%u", fn, eventData->status); + SyncEventGuard guard (sSecElem.mAidAddRemoveEvent); + sSecElem.mAidAddRemoveEvent.notifyOne (); + } + break; + + case NFA_EE_REMOVE_AID_EVT: + { + ALOGD ("%s: NFA_EE_REMOVE_AID_EVT status=%u", fn, eventData->status); + SyncEventGuard guard (sSecElem.mAidAddRemoveEvent); + sSecElem.mAidAddRemoveEvent.notifyOne (); + } + break; + + case NFA_EE_NEW_EE_EVT: + { + ALOGD ("%s: NFA_EE_NEW_EE_EVT h=0x%X; status=%u", fn, + eventData->new_ee.ee_handle, eventData->new_ee.ee_status); + // Indicate there are new EE + sSecElem.mbNewEE = true; + } + break; + + default: + ALOGE ("%s: unknown event=%u ????", fn, event); + break; + } +} + +/******************************************************************************* +** +** Function getSeVerInfo +** +** Description Gets version information and id for a secure element. The +** seIndex parmeter is the zero based index of the secure +** element to get verion info for. The version infommation +** is returned as a string int the verInfo parameter. +** +** Returns ture on success, false on failure +** +*******************************************************************************/ +bool SecureElement::getSeVerInfo(int seIndex, char * verInfo, int verInfoSz, UINT8 * seid) +{ + ALOGD("%s: enter, seIndex=%d", __FUNCTION__, seIndex); + + if (seIndex > (mActualNumEe-1)) + { + ALOGE("%s: invalid se index: %d, only %d SEs in system", __FUNCTION__, seIndex, mActualNumEe); + return false; + } + + *seid = mEeInfo[seIndex].ee_handle; + + if ((mEeInfo[seIndex].num_interface == 0) || (mEeInfo[seIndex].ee_interface[0] == NCI_NFCEE_INTERFACE_HCI_ACCESS) ) + { + return false; + } + + strncpy(verInfo, "Version info not available", verInfoSz-1); + verInfo[verInfoSz-1] = '\0'; + + UINT8 pipe = (mEeInfo[seIndex].ee_handle == EE_HANDLE_0xF3) ? 0x70 : 0x71; + UINT8 host = (pipe == STATIC_PIPE_0x70) ? 0x02 : 0x03; + UINT8 gate = (pipe == STATIC_PIPE_0x70) ? 0xF0 : 0xF1; + + tNFA_STATUS nfaStat = NFA_HciAddStaticPipe(mNfaHciHandle, host, gate, pipe); + if (nfaStat != NFA_STATUS_OK) + { + ALOGE ("%s: NFA_HciAddStaticPipe() failed, pipe = 0x%x, error=0x%X", __FUNCTION__, pipe, nfaStat); + return true; + } + + SyncEventGuard guard (mVerInfoEvent); + if (NFA_STATUS_OK == (nfaStat = NFA_HciGetRegistry (mNfaHciHandle, pipe, 0x02))) + { + if (false == mVerInfoEvent.wait(200)) + { + ALOGE ("%s: wait response timeout", __FUNCTION__); + } + else + { + snprintf(verInfo, verInfoSz-1, "Oberthur OS S/N: 0x%02x%02x%02x", mVerInfo[0], mVerInfo[1], mVerInfo[2]); + verInfo[verInfoSz-1] = '\0'; + } + } + else + { + ALOGE ("%s: NFA_HciGetRegistry () failed: 0x%X", __FUNCTION__, nfaStat); + } + return true; +} + +/******************************************************************************* +** +** Function getActualNumEe +** +** Description Returns number of secure elements we know about. +** +** Returns Number of secure elements we know about. +** +*******************************************************************************/ +UINT8 SecureElement::getActualNumEe() +{ + return mActualNumEe; +} + +/******************************************************************************* +** +** Function: nfaHciCallback +** +** Description: Receive Host Controller Interface-related events from stack. +** event: Event code. +** eventData: Event data. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::nfaHciCallback (tNFA_HCI_EVT event, tNFA_HCI_EVT_DATA* eventData) +{ + static const char fn [] = "SecureElement::nfaHciCallback"; + ALOGD ("%s: event=0x%X", fn, event); + + switch (event) + { + case NFA_HCI_REGISTER_EVT: + { + ALOGD ("%s: NFA_HCI_REGISTER_EVT; status=0x%X; handle=0x%X", fn, + eventData->hci_register.status, eventData->hci_register.hci_handle); + SyncEventGuard guard (sSecElem.mHciRegisterEvent); + sSecElem.mNfaHciHandle = eventData->hci_register.hci_handle; + sSecElem.mHciRegisterEvent.notifyOne(); + } + break; + + case NFA_HCI_ALLOCATE_GATE_EVT: + { + ALOGD ("%s: NFA_HCI_ALLOCATE_GATE_EVT; status=0x%X; gate=0x%X", fn, eventData->status, eventData->allocated.gate); + SyncEventGuard guard (sSecElem.mAllocateGateEvent); + sSecElem.mCommandStatus = eventData->status; + sSecElem.mNewSourceGate = (eventData->allocated.status == NFA_STATUS_OK) ? eventData->allocated.gate : 0; + sSecElem.mAllocateGateEvent.notifyOne(); + } + break; + + case NFA_HCI_DEALLOCATE_GATE_EVT: + { + tNFA_HCI_DEALLOCATE_GATE& deallocated = eventData->deallocated; + ALOGD ("%s: NFA_HCI_DEALLOCATE_GATE_EVT; status=0x%X; gate=0x%X", fn, deallocated.status, deallocated.gate); + SyncEventGuard guard (sSecElem.mDeallocateGateEvent); + sSecElem.mDeallocateGateEvent.notifyOne(); + } + break; + + case NFA_HCI_GET_GATE_PIPE_LIST_EVT: + { + ALOGD ("%s: NFA_HCI_GET_GATE_PIPE_LIST_EVT; status=0x%X; num_pipes: %u num_gates: %u", fn, + eventData->gates_pipes.status, eventData->gates_pipes.num_pipes, eventData->gates_pipes.num_gates); + SyncEventGuard guard (sSecElem.mPipeListEvent); + sSecElem.mCommandStatus = eventData->gates_pipes.status; + sSecElem.mHciCfg = eventData->gates_pipes; + sSecElem.mPipeListEvent.notifyOne(); + } + break; + + case NFA_HCI_CREATE_PIPE_EVT: + { + ALOGD ("%s: NFA_HCI_CREATE_PIPE_EVT; status=0x%X; pipe=0x%X; src gate=0x%X; dest host=0x%X; dest gate=0x%X", fn, + eventData->created.status, eventData->created.pipe, eventData->created.source_gate, eventData->created.dest_host, eventData->created.dest_gate); + SyncEventGuard guard (sSecElem.mCreatePipeEvent); + sSecElem.mCommandStatus = eventData->created.status; + sSecElem.mNewPipeId = eventData->created.pipe; + sSecElem.mCreatePipeEvent.notifyOne(); + } + break; + + case NFA_HCI_OPEN_PIPE_EVT: + { + ALOGD ("%s: NFA_HCI_OPEN_PIPE_EVT; status=0x%X; pipe=0x%X", fn, eventData->opened.status, eventData->opened.pipe); + SyncEventGuard guard (sSecElem.mPipeOpenedEvent); + sSecElem.mCommandStatus = eventData->opened.status; + sSecElem.mPipeOpenedEvent.notifyOne(); + } + break; + + case NFA_HCI_EVENT_SENT_EVT: + ALOGD ("%s: NFA_HCI_EVENT_SENT_EVT; status=0x%X", fn, eventData->evt_sent.status); + break; + + case NFA_HCI_RSP_RCVD_EVT: //response received from secure element + { + tNFA_HCI_RSP_RCVD& rsp_rcvd = eventData->rsp_rcvd; + ALOGD ("%s: NFA_HCI_RSP_RCVD_EVT; status: 0x%X; code: 0x%X; pipe: 0x%X; len: %u", fn, + rsp_rcvd.status, rsp_rcvd.rsp_code, rsp_rcvd.pipe, rsp_rcvd.rsp_len); + } + break; + + case NFA_HCI_GET_REG_RSP_EVT : + ALOGD ("%s: NFA_HCI_GET_REG_RSP_EVT; status: 0x%X; pipe: 0x%X, len: %d", fn, + eventData->registry.status, eventData->registry.pipe, eventData->registry.data_len); + if (eventData->registry.data_len >= 19 && ((eventData->registry.pipe == STATIC_PIPE_0x70) || (eventData->registry.pipe == STATIC_PIPE_0x71))) + { + SyncEventGuard guard (sSecElem.mVerInfoEvent); + // Oberthur OS version is in bytes 16,17, and 18 + sSecElem.mVerInfo[0] = eventData->registry.reg_data[16]; + sSecElem.mVerInfo[1] = eventData->registry.reg_data[17]; + sSecElem.mVerInfo[2] = eventData->registry.reg_data[18]; + sSecElem.mVerInfoEvent.notifyOne (); + } + break; + + case NFA_HCI_EVENT_RCVD_EVT: + ALOGD ("%s: NFA_HCI_EVENT_RCVD_EVT; code: 0x%X; pipe: 0x%X; data len: %u", fn, + eventData->rcvd_evt.evt_code, eventData->rcvd_evt.pipe, eventData->rcvd_evt.evt_len); + if ((eventData->rcvd_evt.pipe == STATIC_PIPE_0x70) || (eventData->rcvd_evt.pipe == STATIC_PIPE_0x71)) + { + ALOGD ("%s: NFA_HCI_EVENT_RCVD_EVT; data from static pipe", fn); + SyncEventGuard guard (sSecElem.mTransceiveEvent); + sSecElem.mActualResponseSize = (eventData->rcvd_evt.evt_len > MAX_RESPONSE_SIZE) ? MAX_RESPONSE_SIZE : eventData->rcvd_evt.evt_len; + sSecElem.mTransceiveEvent.notifyOne (); + } + else if (eventData->rcvd_evt.evt_code == NFA_HCI_EVT_POST_DATA) + { + ALOGD ("%s: NFA_HCI_EVENT_RCVD_EVT; NFA_HCI_EVT_POST_DATA", fn); + SyncEventGuard guard (sSecElem.mTransceiveEvent); + sSecElem.mActualResponseSize = (eventData->rcvd_evt.evt_len > MAX_RESPONSE_SIZE) ? MAX_RESPONSE_SIZE : eventData->rcvd_evt.evt_len; + sSecElem.mTransceiveEvent.notifyOne (); + } + else if (eventData->rcvd_evt.evt_code == NFA_HCI_EVT_TRANSACTION) + { + ALOGD ("%s: NFA_HCI_EVENT_RCVD_EVT; NFA_HCI_EVT_TRANSACTION", fn); + // If we got an AID, notify any listeners + if ((eventData->rcvd_evt.evt_len > 3) && (eventData->rcvd_evt.p_evt_buf[0] == 0x81) ) + sSecElem.notifyTransactionListenersOfAid (&eventData->rcvd_evt.p_evt_buf[2], eventData->rcvd_evt.p_evt_buf[1]); + } + break; + + case NFA_HCI_SET_REG_RSP_EVT: //received response to write registry command + { + tNFA_HCI_REGISTRY& registry = eventData->registry; + ALOGD ("%s: NFA_HCI_SET_REG_RSP_EVT; status=0x%X; pipe=0x%X", fn, registry.status, registry.pipe); + SyncEventGuard guard (sSecElem.mRegistryEvent); + sSecElem.mRegistryEvent.notifyOne (); + break; + } + + default: + ALOGE ("%s: unknown event code=0x%X ????", fn, event); + break; + } +} + + +/******************************************************************************* +** +** Function: findEeByHandle +** +** Description: Find information about an execution environment. +** eeHandle: Handle to execution environment. +** +** Returns: Information about an execution environment. +** +*******************************************************************************/ +tNFA_EE_INFO *SecureElement::findEeByHandle (tNFA_HANDLE eeHandle) +{ + for (UINT8 xx = 0; xx < mActualNumEe; xx++) + { + if (mEeInfo[xx].ee_handle == eeHandle) + return (&mEeInfo[xx]); + } + return (NULL); +} + + +/******************************************************************************* +** +** Function: getDefaultEeHandle +** +** Description: Get the handle to the execution environment. +** +** Returns: Handle to the execution environment. +** +*******************************************************************************/ +tNFA_HANDLE SecureElement::getDefaultEeHandle () +{ + // Find the first EE that is not the HCI Access i/f. + for (UINT8 xx = 0; xx < mActualNumEe; xx++) + { + if ((mEeInfo[xx].num_interface != 0) && (mEeInfo[xx].ee_interface[0] != NCI_NFCEE_INTERFACE_HCI_ACCESS) ) + return (mEeInfo[xx].ee_handle); + } + return NFA_HANDLE_INVALID; +} + + + /******************************************************************************* + ** + ** Function: findUiccByHandle + ** + ** Description: Find information about an execution environment. + ** eeHandle: Handle of the execution environment. + ** + ** Returns: Information about the execution environment. + ** + *******************************************************************************/ +tNFA_EE_DISCOVER_INFO *SecureElement::findUiccByHandle (tNFA_HANDLE eeHandle) +{ + for (UINT8 index = 0; index < mUiccInfo.num_ee; index++) + { + if (mUiccInfo.ee_disc_info[index].ee_handle == eeHandle) + { + return (&mUiccInfo.ee_disc_info[index]); + } + } + ALOGE ("SecureElement::findUiccByHandle: ee h=0x%4x not found", eeHandle); + return NULL; +} + + +/******************************************************************************* +** +** Function: eeStatusToString +** +** Description: Convert status code to status text. +** status: Status code +** +** Returns: None +** +*******************************************************************************/ +const char* SecureElement::eeStatusToString (UINT8 status) +{ + switch (status) + { + case NFC_NFCEE_STATUS_ACTIVE: + return("Connected/Active"); + case NFC_NFCEE_STATUS_INACTIVE: + return("Connected/Inactive"); + case NFC_NFCEE_STATUS_REMOVED: + return("Removed"); + } + return("?? Unknown ??"); +} + + +/******************************************************************************* +** +** Function: connectionEventHandler +** +** Description: Receive card-emulation related events from stack. +** event: Event code. +** eventData: Event data. +** +** Returns: None +** +*******************************************************************************/ +void SecureElement::connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* eventData) +{ + switch (event) + { + case NFA_CE_UICC_LISTEN_CONFIGURED_EVT: + { + SyncEventGuard guard (mUiccListenEvent); + mUiccListenEvent.notifyOne (); + } + break; + } +} + + +/******************************************************************************* +** +** Function: routeToSecureElement +** +** Description: Adjust controller's listen-mode routing table so transactions +** are routed to the secure elements. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::routeToSecureElement () +{ + static const char fn [] = "SecureElement::routeToSecureElement"; + ALOGD ("%s: enter", fn); + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + tNFA_TECHNOLOGY_MASK tech_mask = NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B; + bool retval = false; + + if (! mIsInit) + { + ALOGE ("%s: not init", fn); + return false; + } + + if (mCurrentRouteSelection == SecElemRoute) + { + ALOGE ("%s: already sec elem route", fn); + return true; + } + + if (mActiveEeHandle == NFA_HANDLE_INVALID) + { + ALOGE ("%s: invalid EE handle", fn); + return false; + } + + adjustRoutes (SecElemRoute); + + { + unsigned long num = 0; + if (GetNumValue("UICC_LISTEN_TECH_MASK", &num, sizeof(num))) + tech_mask = num; + ALOGD ("%s: start UICC listen; h=0x%X; tech mask=0x%X", fn, mActiveEeHandle, tech_mask); + SyncEventGuard guard (mUiccListenEvent); + nfaStat = NFA_CeConfigureUiccListenTech (mActiveEeHandle, tech_mask); + if (nfaStat == NFA_STATUS_OK) + { + mUiccListenEvent.wait (); + retval = true; + } + else + ALOGE ("%s: fail to start UICC listen", fn); + } + + ALOGD ("%s: exit; ok=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: routeToDefault +** +** Description: Adjust controller's listen-mode routing table so transactions +** are routed to the default destination. +** +** Returns: True if ok. +** +*******************************************************************************/ +bool SecureElement::routeToDefault () +{ + static const char fn [] = "SecureElement::routeToDefault"; + tNFA_STATUS nfaStat = NFA_STATUS_FAILED; + bool retval = false; + + ALOGD ("%s: enter", fn); + if (! mIsInit) + { + ALOGE ("%s: not init", fn); + return false; + } + + if (mCurrentRouteSelection == DefaultRoute) + { + ALOGD ("%s: already default route", fn); + return true; + } + + if (mActiveEeHandle != NFA_HANDLE_INVALID) + { + ALOGD ("%s: stop UICC listen; EE h=0x%X", fn, mActiveEeHandle); + SyncEventGuard guard (mUiccListenEvent); + nfaStat = NFA_CeConfigureUiccListenTech (mActiveEeHandle, 0); + if (nfaStat == NFA_STATUS_OK) + { + mUiccListenEvent.wait (); + retval = true; + } + else + ALOGE ("%s: fail to stop UICC listen", fn); + } + else + retval = true; + + adjustRoutes (DefaultRoute); + + ALOGD ("%s: exit; ok=%u", fn, retval); + return retval; +} + + +/******************************************************************************* +** +** Function: isBusy +** +** Description: Whether controller is routing listen-mode events to +** secure elements or a pipe is connected. +** +** Returns: True if either case is true. +** +*******************************************************************************/ +bool SecureElement::isBusy () +{ + bool retval = (mCurrentRouteSelection == SecElemRoute) || mIsPiping; + ALOGD ("SecureElement::isBusy: %u", retval); + return retval; +} + diff --git a/nci/jni/SecureElement.h b/nci/jni/SecureElement.h new file mode 100755 index 0000000..1758590 --- /dev/null +++ b/nci/jni/SecureElement.h @@ -0,0 +1,607 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Communicate with secure elements that are attached to the NFC + * controller. + */ +#pragma once +#include "SyncEvent.h" +#include "DataQueue.h" +#include "NfcJniUtil.h" +#include "RouteDataSet.h" +extern "C" +{ + #include "nfa_ee_api.h" + #include "nfa_hci_api.h" + #include "nfa_hci_defs.h" + #include "nfa_ce_api.h" +} + + +class SecureElement +{ +public: + tNFA_HANDLE mActiveEeHandle; + + + /******************************************************************************* + ** + ** Function: getInstance + ** + ** Description: Get the SecureElement singleton object. + ** + ** Returns: SecureElement object. + ** + *******************************************************************************/ + static SecureElement& getInstance (); + + + /******************************************************************************* + ** + ** Function: initialize + ** + ** Description: Initialize all member variables. + ** native: Native data. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool initialize (nfc_jni_native_data* native); + + + /******************************************************************************* + ** + ** Function: finalize + ** + ** Description: Release all resources. + ** + ** Returns: None + ** + *******************************************************************************/ + void finalize (); + + + /******************************************************************************* + ** + ** Function: getListOfEeHandles + ** + ** Description: Get the list of handles of all execution environments. + ** e: Java Virtual Machine. + ** + ** Returns: List of handles of all execution environments. + ** + *******************************************************************************/ + jintArray getListOfEeHandles (JNIEnv* e); + + + /******************************************************************************* + ** + ** Function: activate + ** + ** Description: Turn on the secure element. + ** seID: ID of secure element. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool activate (jint seID); + + + /******************************************************************************* + ** + ** Function: deactivate + ** + ** Description: Turn off the secure element. + ** seID: ID of secure element. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool deactivate (jint seID); + + + /******************************************************************************* + ** + ** Function: connectEE + ** + ** Description: Connect to the execution environment. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool connectEE (); + + + /******************************************************************************* + ** + ** Function: disconnectEE + ** + ** Description: Disconnect from the execution environment. + ** seID: ID of secure element. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool disconnectEE (jint seID); + + + /******************************************************************************* + ** + ** Function: transceive + ** + ** Description: Send data to the secure element; read it's response. + ** xmitBuffer: Data to transmit. + ** xmitBufferSize: Length of data. + ** recvBuffer: Buffer to receive response. + ** recvBufferMaxSize: Maximum size of buffer. + ** recvBufferActualSize: Actual length of response. + ** timeoutMillisec: timeout in millisecond + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool transceive (UINT8* xmitBuffer, INT32 xmitBufferSize, UINT8* recvBuffer, + INT32 recvBufferMaxSize, INT32& recvBufferActualSize, INT32 timeoutMillisec); + + /******************************************************************************* + ** + ** Function: notifyListenModeState + ** + ** Description: Notify the NFC service about whether the SE was activated + ** in listen mode. + ** isActive: Whether the secure element is activated. + ** + ** Returns: None + ** + *******************************************************************************/ + void notifyListenModeState (bool isActivated); + + /******************************************************************************* + ** + ** Function: notifyRfFieldEvent + ** + ** Description: Notify the NFC service about RF field events from the stack. + ** isActive: Whether any secure element is activated. + ** + ** Returns: None + ** + *******************************************************************************/ + void notifyRfFieldEvent (bool isActive); + + + /******************************************************************************* + ** + ** Function: storeUiccInfo + ** + ** Description: Store a copy of the execution environment information from the stack. + ** info: execution environment information. + ** + ** Returns: None + ** + *******************************************************************************/ + void storeUiccInfo (tNFA_EE_DISCOVER_REQ& info); + + + /******************************************************************************* + ** + ** Function: getUiccId + ** + ** Description: Get the ID of the secure element. + ** eeHandle: Handle to the secure element. + ** uid: Array to receive the ID. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool getUiccId (tNFA_HANDLE eeHandle, jbyteArray& uid); + + + /******************************************************************************* + ** + ** Function: getTechnologyList + ** + ** Description: Get all the technologies supported by a secure element. + ** eeHandle: Handle of secure element. + ** techList: List to receive the technologies. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool getTechnologyList (tNFA_HANDLE eeHandle, jintArray& techList); + + + /******************************************************************************* + ** + ** Function: notifyTransactionListenersOfAid + ** + ** Description: Notify the NFC service about a transaction event from secure element. + ** aid: Buffer contains application ID. + ** aidLen: Length of application ID. + ** + ** Returns: None + ** + *******************************************************************************/ + void notifyTransactionListenersOfAid (const UINT8* aid, UINT8 aidLen); + + + /******************************************************************************* + ** + ** Function: notifyTransactionListenersOfTlv + ** + ** Description: Notify the NFC service about a transaction event from secure element. + ** The type-length-value contains AID and parameter. + ** tlv: type-length-value encoded in Basic Encoding Rule. + ** tlvLen: Length tlv. + ** + ** Returns: None + ** + *******************************************************************************/ + void notifyTransactionListenersOfTlv (const UINT8* tlv, UINT8 tlvLen); + + + /******************************************************************************* + ** + ** Function: connectionEventHandler + ** + ** Description: Receive card-emulation related events from stack. + ** event: Event code. + ** eventData: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + void connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* eventData); + + + /******************************************************************************* + ** + ** Function: applyRoutes + ** + ** Description: Read route data from XML and apply them again + ** to every secure element. + ** + ** Returns: None + ** + *******************************************************************************/ + void applyRoutes (); + + + /******************************************************************************* + ** + ** Function: setActiveSeOverride + ** + ** Description: Specify which secure element to turn on. + ** activeSeOverride: ID of secure element + ** + ** Returns: None + ** + *******************************************************************************/ + void setActiveSeOverride (UINT8 activeSeOverride); + + + /******************************************************************************* + ** + ** Function: routeToSecureElement + ** + ** Description: Adjust controller's listen-mode routing table so transactions + ** are routed to the secure elements as specified in route.xml. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool routeToSecureElement (); + + + /******************************************************************************* + ** + ** Function: routeToDefault + ** + ** Description: Adjust controller's listen-mode routing table so transactions + ** are routed to the default destination specified in route.xml. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool routeToDefault (); + + + /******************************************************************************* + ** + ** Function: isBusy + ** + ** Description: Whether NFC controller is routing listen-mode events or a pipe is connected. + ** + ** Returns: True if either case is true. + ** + *******************************************************************************/ + bool isBusy (); + + + /******************************************************************************* + ** + ** Function getActualNumEe + ** + ** Description Returns number of secure elements we know about. + ** + ** Returns Number of secure elements we know about. + ** + *******************************************************************************/ + UINT8 getActualNumEe(); + + + /******************************************************************************* + ** + ** Function getSeVerInfo + ** + ** Description Gets version information and id for a secure element. The + ** seIndex parmeter is the zero based index of the secure + ** element to get verion info for. The version infommation + ** is returned as a string int the verInfo parameter. + ** + ** Returns ture on success, false on failure + ** + *******************************************************************************/ + bool getSeVerInfo(int seIndex, char * verInfo, int verInfoSz, UINT8 * seid); + + + /******************************************************************************* + ** + ** Function: isActivatedInListenMode + ** + ** Description: Can be used to determine if the SE is activated in listen mode + ** + ** Returns: True if the SE is activated in listen mode + ** + *******************************************************************************/ + bool isActivatedInListenMode(); + + /******************************************************************************* + ** + ** Function: isRfFieldOn + ** + ** Description: Can be used to determine if the SE is in an RF field + ** + ** Returns: True if the SE is activated in an RF field + ** + *******************************************************************************/ + bool isRfFieldOn(); + +private: + static const unsigned int MAX_RESPONSE_SIZE = 1024; + enum RouteSelection {NoRoute, DefaultRoute, SecElemRoute}; + static const int MAX_NUM_EE = 5; //max number of EE's + static const UINT8 STATIC_PIPE_0x70 = 0x70; //Broadcom's proprietary static pipe + static const UINT8 STATIC_PIPE_0x71 = 0x71; //Broadcom's proprietary static pipe + static const UINT8 EVT_SEND_DATA = 0x10; //see specification ETSI TS 102 622 v9.0.0 (Host Controller Interface); section 9.3.3.3 + static const tNFA_HANDLE EE_HANDLE_0xF3 = 0x4F3; //handle to secure element in slot 0 + static const tNFA_HANDLE EE_HANDLE_0xF4 = 0x4F4; //handle to secure element in slot 1 + static SecureElement sSecElem; + static const char* APP_NAME; + + UINT8 mDestinationGate; //destination gate of the UICC + tNFA_HANDLE mNfaHciHandle; //NFA handle to NFA's HCI component + nfc_jni_native_data* mNativeData; + bool mIsInit; // whether EE is initialized + UINT8 mActualNumEe; // actual number of EE's reported by the stack + UINT8 mNumEePresent; // actual number of usable EE's + bool mbNewEE; + UINT8 mNewPipeId; + UINT8 mNewSourceGate; + UINT16 mActiveSeOverride; // active "enable" seid, 0 means activate all SEs + tNFA_STATUS mCommandStatus; //completion status of the last command + bool mIsPiping; //is a pipe connected to the controller? + RouteSelection mCurrentRouteSelection; + int mActualResponseSize; //number of bytes in the response received from secure element + bool mUseOberthurWarmReset; //whether to use warm-reset command + bool mActivatedInListenMode; // whether we're activated in listen mode + UINT8 mOberthurWarmResetCommand; //warm-reset command byte + tNFA_EE_INFO mEeInfo [MAX_NUM_EE]; //actual size stored in mActualNumEe + tNFA_EE_DISCOVER_REQ mUiccInfo; + tNFA_HCI_GET_GATE_PIPE_LIST mHciCfg; + SyncEvent mEeRegisterEvent; + SyncEvent mHciRegisterEvent; + SyncEvent mEeSetModeEvent; + SyncEvent mPipeListEvent; + SyncEvent mCreatePipeEvent; + SyncEvent mPipeOpenedEvent; + SyncEvent mAllocateGateEvent; + SyncEvent mDeallocateGateEvent; + SyncEvent mRoutingEvent; + SyncEvent mUiccInfoEvent; + SyncEvent mUiccListenEvent; + SyncEvent mAidAddRemoveEvent; + SyncEvent mTransceiveEvent; + SyncEvent mVerInfoEvent; + SyncEvent mRegistryEvent; + UINT8 mVerInfo [3]; + UINT8 mResponseData [MAX_RESPONSE_SIZE]; + RouteDataSet mRouteDataSet; //routing data + std::vector mUsedAids; //AID's that are used in current routes + UINT8 mAidForEmptySelect[NCI_MAX_AID_LEN+1]; + Mutex mMutex; // protects fields below + bool mRfFieldIsOn; // last known RF field state + struct timespec mLastRfFieldToggle; // last time RF field went off + /******************************************************************************* + ** + ** Function: SecureElement + ** + ** Description: Initialize member variables. + ** + ** Returns: None + ** + *******************************************************************************/ + SecureElement (); + + + /******************************************************************************* + ** + ** Function: ~SecureElement + ** + ** Description: Release all resources. + ** + ** Returns: None + ** + *******************************************************************************/ + ~SecureElement (); + + + /******************************************************************************* + ** + ** Function: nfaEeCallback + ** + ** Description: Receive execution environment-related events from stack. + ** event: Event code. + ** eventData: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + static void nfaEeCallback (tNFA_EE_EVT event, tNFA_EE_CBACK_DATA* eventData); + + + /******************************************************************************* + ** + ** Function: nfaHciCallback + ** + ** Description: Receive Host Controller Interface-related events from stack. + ** event: Event code. + ** eventData: Event data. + ** + ** Returns: None + ** + *******************************************************************************/ + static void nfaHciCallback (tNFA_HCI_EVT event, tNFA_HCI_EVT_DATA* eventData); + + + /******************************************************************************* + ** + ** Function: findEeByHandle + ** + ** Description: Find information about an execution environment. + ** eeHandle: Handle to execution environment. + ** + ** Returns: Information about an execution environment. + ** + *******************************************************************************/ + tNFA_EE_INFO *findEeByHandle (tNFA_HANDLE eeHandle); + + + /******************************************************************************* + ** + ** Function: findUiccByHandle + ** + ** Description: Find information about an execution environment. + ** eeHandle: Handle of the execution environment. + ** + ** Returns: Information about the execution environment. + ** + *******************************************************************************/ + tNFA_EE_DISCOVER_INFO *findUiccByHandle (tNFA_HANDLE eeHandle); + + + /******************************************************************************* + ** + ** Function: getDefaultEeHandle + ** + ** Description: Get the handle to the execution environment. + ** + ** Returns: Handle to the execution environment. + ** + *******************************************************************************/ + tNFA_HANDLE getDefaultEeHandle (); + + + /******************************************************************************* + ** + ** Function: adjustRoutes + ** + ** Description: Adjust routes in the controller's listen-mode routing table. + ** selection: which set of routes to configure the controller. + ** + ** Returns: None + ** + *******************************************************************************/ + void adjustRoutes (RouteSelection selection); + + + /******************************************************************************* + ** + ** Function: adjustProtocolRoutes + ** + ** Description: Adjust default routing based on protocol in NFC listen mode. + ** isRouteToEe: Whether routing to EE (true) or host (false). + ** + ** Returns: None + ** + *******************************************************************************/ + void adjustProtocolRoutes (RouteDataSet::Database* db, RouteSelection routeSelection); + + + /******************************************************************************* + ** + ** Function: adjustTechnologyRoutes + ** + ** Description: Adjust default routing based on technology in NFC listen mode. + ** isRouteToEe: Whether routing to EE (true) or host (false). + ** + ** Returns: None + ** + *******************************************************************************/ + void adjustTechnologyRoutes (RouteDataSet::Database* db, RouteSelection routeSelection); + + + /******************************************************************************* + ** + ** Function: getEeInfo + ** + ** Description: Get latest information about execution environments from stack. + ** + ** Returns: True if at least 1 EE is available. + ** + *******************************************************************************/ + bool getEeInfo (); + + /******************************************************************************* + ** + ** Function: eeStatusToString + ** + ** Description: Convert status code to status text. + ** status: Status code + ** + ** Returns: None + ** + *******************************************************************************/ + static const char* eeStatusToString (UINT8 status); + + + /******************************************************************************* + ** + ** Function: encodeAid + ** + ** Description: Encode AID in type-length-value using Basic Encoding Rule. + ** tlv: Buffer to store TLV. + ** tlvMaxLen: TLV buffer's maximum length. + ** tlvActualLen: TLV buffer's actual length. + ** aid: Buffer of Application ID. + ** aidLen: Aid buffer's actual length. + ** + ** Returns: True if ok. + ** + *******************************************************************************/ + bool encodeAid (UINT8* tlv, UINT16 tlvMaxLen, UINT16& tlvActualLen, const UINT8* aid, UINT8 aidLen); +}; + diff --git a/nci/jni/SyncEvent.h b/nci/jni/SyncEvent.h new file mode 100644 index 0000000..5fd389e --- /dev/null +++ b/nci/jni/SyncEvent.h @@ -0,0 +1,171 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Synchronize two or more threads using a condition variable and a mutex. + */ +#pragma once +#include "CondVar.h" +#include "Mutex.h" + + +class SyncEvent +{ +public: + /******************************************************************************* + ** + ** Function: ~SyncEvent + ** + ** Description: Cleanup all resources. + ** + ** Returns: None. + ** + *******************************************************************************/ + ~SyncEvent () + { + } + + + /******************************************************************************* + ** + ** Function: start + ** + ** Description: Start a synchronization operation. + ** + ** Returns: None. + ** + *******************************************************************************/ + void start () + { + mMutex.lock (); + } + + + /******************************************************************************* + ** + ** Function: wait + ** + ** Description: Block the thread and wait for the event to occur. + ** + ** Returns: None. + ** + *******************************************************************************/ + void wait () + { + mCondVar.wait (mMutex); + } + + + /******************************************************************************* + ** + ** Function: wait + ** + ** Description: Block the thread and wait for the event to occur. + ** millisec: Timeout in milliseconds. + ** + ** Returns: True if wait is successful; false if timeout occurs. + ** + *******************************************************************************/ + bool wait (long millisec) + { + bool retVal = mCondVar.wait (mMutex, millisec); + return retVal; + } + + + /******************************************************************************* + ** + ** Function: notifyOne + ** + ** Description: Notify a blocked thread that the event has occured. Unblocks it. + ** + ** Returns: None. + ** + *******************************************************************************/ + void notifyOne () + { + mCondVar.notifyOne (); + } + + + /******************************************************************************* + ** + ** Function: end + ** + ** Description: End a synchronization operation. + ** + ** Returns: None. + ** + *******************************************************************************/ + void end () + { + mMutex.unlock (); + } + +private: + CondVar mCondVar; + Mutex mMutex; +}; + + +/*****************************************************************************/ +/*****************************************************************************/ + + +/***************************************************************************** +** +** Name: SyncEventGuard +** +** Description: Automatically start and end a synchronization event. +** +*****************************************************************************/ +class SyncEventGuard +{ +public: + /******************************************************************************* + ** + ** Function: SyncEventGuard + ** + ** Description: Start a synchronization operation. + ** + ** Returns: None. + ** + *******************************************************************************/ + SyncEventGuard (SyncEvent& event) + : mEvent (event) + { + event.start (); //automatically start operation + }; + + + /******************************************************************************* + ** + ** Function: ~SyncEventGuard + ** + ** Description: End a synchronization operation. + ** + ** Returns: None. + ** + *******************************************************************************/ + ~SyncEventGuard () + { + mEvent.end (); //automatically end operation + }; + +private: + SyncEvent& mEvent; +}; + diff --git a/nci/src/com/android/nfc/dhimpl/NativeLlcpConnectionlessSocket.java b/nci/src/com/android/nfc/dhimpl/NativeLlcpConnectionlessSocket.java new file mode 100755 index 0000000..db78496 --- /dev/null +++ b/nci/src/com/android/nfc/dhimpl/NativeLlcpConnectionlessSocket.java @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.nfc.dhimpl; + +import com.android.nfc.DeviceHost; +import com.android.nfc.LlcpPacket; + +import java.io.IOException; + +/** + * LlcpConnectionlessSocket represents a LLCP Connectionless object to be used + * in a connectionless communication + */ +public class NativeLlcpConnectionlessSocket implements DeviceHost.LlcpConnectionlessSocket { + + private int mHandle; + private int mSap; + private int mLinkMiu; + + public NativeLlcpConnectionlessSocket() { } + + public native boolean doSendTo(int sap, byte[] data); + + public native LlcpPacket doReceiveFrom(int linkMiu); + + public native boolean doClose(); + + @Override + public int getLinkMiu(){ + return mLinkMiu; + } + + @Override + public int getSap(){ + return mSap; + } + + @Override + public void send(int sap, byte[] data) throws IOException { + if (!doSendTo(sap, data)) { + throw new IOException(); + } + } + + @Override + public LlcpPacket receive() throws IOException { + LlcpPacket packet = doReceiveFrom(mLinkMiu); + if (packet == null) { + throw new IOException(); + } + return packet; + } + + public int getHandle(){ + return mHandle; + } + + @Override + public void close() throws IOException { + if (!doClose()) { + throw new IOException(); + } + } +} diff --git a/nci/src/com/android/nfc/dhimpl/NativeLlcpServiceSocket.java b/nci/src/com/android/nfc/dhimpl/NativeLlcpServiceSocket.java new file mode 100755 index 0000000..3a7e57f --- /dev/null +++ b/nci/src/com/android/nfc/dhimpl/NativeLlcpServiceSocket.java @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.nfc.dhimpl; + +import com.android.nfc.DeviceHost; +import com.android.nfc.DeviceHost.LlcpSocket; + +import java.io.IOException; + +/** + * LlcpServiceSocket represents a LLCP Service to be used in a + * Connection-oriented communication + */ +public class NativeLlcpServiceSocket implements DeviceHost.LlcpServerSocket { + private int mHandle; + private int mLocalMiu; + private int mLocalRw; + private int mLocalLinearBufferLength; + private int mSap; + private String mServiceName; + + public NativeLlcpServiceSocket(){ } + + private native NativeLlcpSocket doAccept(int miu, int rw, int linearBufferLength); + @Override + public LlcpSocket accept() throws IOException { + LlcpSocket socket = doAccept(mLocalMiu, mLocalRw, mLocalLinearBufferLength); + if (socket == null) throw new IOException(); + return socket; + } + + private native boolean doClose(); + @Override + public void close() throws IOException { + if (!doClose()) { + throw new IOException(); + } + } +} diff --git a/nci/src/com/android/nfc/dhimpl/NativeLlcpSocket.java b/nci/src/com/android/nfc/dhimpl/NativeLlcpSocket.java new file mode 100755 index 0000000..69506c5 --- /dev/null +++ b/nci/src/com/android/nfc/dhimpl/NativeLlcpSocket.java @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.nfc.dhimpl; + +import com.android.nfc.DeviceHost; + +import java.io.IOException; + +/** + * LlcpClientSocket represents a LLCP Connection-Oriented client to be used in a + * connection-oriented communication + */ +public class NativeLlcpSocket implements DeviceHost.LlcpSocket { + private int mHandle; + private int mSap; + private int mLocalMiu; + private int mLocalRw; + + public NativeLlcpSocket(){ } + + private native boolean doConnect(int nSap); + @Override + public void connectToSap(int sap) throws IOException { + if (!doConnect(sap)) { + throw new IOException(); + } + } + + private native boolean doConnectBy(String sn); + @Override + public void connectToService(String serviceName) throws IOException { + if (!doConnectBy(serviceName)) { + throw new IOException(); + } + } + + private native boolean doClose(); + @Override + public void close() throws IOException { + if (!doClose()) { + throw new IOException(); + } + } + + private native boolean doSend(byte[] data); + @Override + public void send(byte[] data) throws IOException { + if (!doSend(data)) { + throw new IOException(); + } + } + + private native int doReceive(byte[] recvBuff); + @Override + public int receive(byte[] recvBuff) throws IOException { + int receiveLength = doReceive(recvBuff); + if (receiveLength == -1) { + throw new IOException(); + } + return receiveLength; + } + + private native int doGetRemoteSocketMiu(); + @Override + public int getRemoteMiu() { return doGetRemoteSocketMiu(); } + + private native int doGetRemoteSocketRw(); + @Override + public int getRemoteRw() { return doGetRemoteSocketRw(); } + + @Override + public int getLocalSap(){ + return mSap; + } + + @Override + public int getLocalMiu(){ + return mLocalMiu; + } + + @Override + public int getLocalRw(){ + return mLocalRw; + } +} diff --git a/nci/src/com/android/nfc/dhimpl/NativeNfcManager.java b/nci/src/com/android/nfc/dhimpl/NativeNfcManager.java new file mode 100755 index 0000000..1437e5d --- /dev/null +++ b/nci/src/com/android/nfc/dhimpl/NativeNfcManager.java @@ -0,0 +1,378 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.nfc.dhimpl; + +import com.android.nfc.DeviceHost; +import com.android.nfc.LlcpException; + +import android.annotation.SdkConstant; +import android.annotation.SdkConstant.SdkConstantType; +import android.content.Context; +import android.content.SharedPreferences; +import android.nfc.ErrorCodes; +import android.nfc.tech.Ndef; +import android.nfc.tech.TagTechnology; +import android.util.Log; + +/** + * Native interface to the NFC Manager functions + */ +public class NativeNfcManager implements DeviceHost { + private static final String TAG = "NativeNfcManager"; + static final String PREF = "NciDeviceHost"; + + static final int DEFAULT_LLCP_MIU = 1980; + static final int DEFAULT_LLCP_RWSIZE = 2; + + static final String DRIVER_NAME = "android-nci"; + + private static final byte[][] EE_WIPE_APDUS = { + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x07, (byte)0xa0, (byte)0x00, + (byte)0x00, (byte)0x04, (byte)0x76, (byte)0x20, (byte)0x10, (byte)0x00}, + {(byte)0x80, (byte)0xe2, (byte)0x01, (byte)0x03, (byte)0x00}, + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x07, (byte)0xa0, (byte)0x00, + (byte)0x00, (byte)0x04, (byte)0x76, (byte)0x30, (byte)0x30, (byte)0x00}, + {(byte)0x80, (byte)0xb4, (byte)0x00, (byte)0x00, (byte)0x00}, + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, + }; + + static { + System.loadLibrary("nfc_nci_jni"); + } + + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String INTERNAL_TARGET_DESELECTED_ACTION = "com.android.nfc.action.INTERNAL_TARGET_DESELECTED"; + + /* Native structure */ + private int mNative; + + private final DeviceHostListener mListener; + private final Context mContext; + + public NativeNfcManager(Context context, DeviceHostListener listener) { + mListener = listener; + initializeNativeStructure(); + mContext = context; + } + + public native boolean initializeNativeStructure(); + + private native boolean doDownload(); + + public native int doGetLastError(); + + @Override + public void checkFirmware() { + } + + private native boolean doInitialize(); + + @Override + public boolean initialize() { + SharedPreferences prefs = mContext.getSharedPreferences(PREF, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = prefs.edit(); + + if (prefs.getBoolean(NativeNfcSecureElement.PREF_SE_WIRED, false)) { + try { + Thread.sleep (12000); + editor.putBoolean(NativeNfcSecureElement.PREF_SE_WIRED, false); + editor.apply(); + } catch (InterruptedException e) { } + } + + return doInitialize(); + } + + private native boolean doDeinitialize(); + + @Override + public boolean deinitialize() { + SharedPreferences prefs = mContext.getSharedPreferences(PREF, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = prefs.edit(); + + editor.putBoolean(NativeNfcSecureElement.PREF_SE_WIRED, false); + editor.apply(); + + return doDeinitialize(); + } + + @Override + public String getName() { + return DRIVER_NAME; + } + + @Override + public native void enableDiscovery(); + + @Override + public native void disableDiscovery(); + + @Override + public native int[] doGetSecureElementList(); + + @Override + public native void doSelectSecureElement(); + + @Override + public native void doDeselectSecureElement(); + + + private native NativeLlcpConnectionlessSocket doCreateLlcpConnectionlessSocket(int nSap, + String sn); + + @Override + public LlcpConnectionlessSocket createLlcpConnectionlessSocket(int nSap, String sn) + throws LlcpException { + LlcpConnectionlessSocket socket = doCreateLlcpConnectionlessSocket(nSap, sn); + if (socket != null) { + return socket; + } else { + /* Get Error Status */ + int error = doGetLastError(); + + Log.d(TAG, "failed to create llcp socket: " + ErrorCodes.asString(error)); + + switch (error) { + case ErrorCodes.ERROR_BUFFER_TO_SMALL: + case ErrorCodes.ERROR_INSUFFICIENT_RESOURCES: + throw new LlcpException(error); + default: + throw new LlcpException(ErrorCodes.ERROR_SOCKET_CREATION); + } + } + } + + private native NativeLlcpServiceSocket doCreateLlcpServiceSocket(int nSap, String sn, int miu, + int rw, int linearBufferLength); + @Override + public LlcpServerSocket createLlcpServerSocket(int nSap, String sn, int miu, + int rw, int linearBufferLength) throws LlcpException { + LlcpServerSocket socket = doCreateLlcpServiceSocket(nSap, sn, miu, rw, linearBufferLength); + if (socket != null) { + return socket; + } else { + /* Get Error Status */ + int error = doGetLastError(); + + Log.d(TAG, "failed to create llcp socket: " + ErrorCodes.asString(error)); + + switch (error) { + case ErrorCodes.ERROR_BUFFER_TO_SMALL: + case ErrorCodes.ERROR_INSUFFICIENT_RESOURCES: + throw new LlcpException(error); + default: + throw new LlcpException(ErrorCodes.ERROR_SOCKET_CREATION); + } + } + } + + private native NativeLlcpSocket doCreateLlcpSocket(int sap, int miu, int rw, + int linearBufferLength); + @Override + public LlcpSocket createLlcpSocket(int sap, int miu, int rw, + int linearBufferLength) throws LlcpException { + LlcpSocket socket = doCreateLlcpSocket(sap, miu, rw, linearBufferLength); + if (socket != null) { + return socket; + } else { + /* Get Error Status */ + int error = doGetLastError(); + + Log.d(TAG, "failed to create llcp socket: " + ErrorCodes.asString(error)); + + switch (error) { + case ErrorCodes.ERROR_BUFFER_TO_SMALL: + case ErrorCodes.ERROR_INSUFFICIENT_RESOURCES: + throw new LlcpException(error); + default: + throw new LlcpException(ErrorCodes.ERROR_SOCKET_CREATION); + } + } + } + + @Override + public native boolean doCheckLlcp(); + + @Override + public native boolean doActivateLlcp(); + + private native void doResetTimeouts(); + + @Override + public void resetTimeouts() { + doResetTimeouts(); + } + + @Override + public native void doAbort(); + + private native boolean doSetTimeout(int tech, int timeout); + @Override + public boolean setTimeout(int tech, int timeout) { + return doSetTimeout(tech, timeout); + } + + private native int doGetTimeout(int tech); + @Override + public int getTimeout(int tech) { + return doGetTimeout(tech); + } + + + @Override + public boolean canMakeReadOnly(int ndefType) { + return (ndefType == Ndef.TYPE_1 || ndefType == Ndef.TYPE_2); + } + + @Override + public int getMaxTransceiveLength(int technology) { + switch (technology) { + case (TagTechnology.NFC_A): + case (TagTechnology.MIFARE_CLASSIC): + case (TagTechnology.MIFARE_ULTRALIGHT): + return 253; // PN544 RF buffer = 255 bytes, subtract two for CRC + case (TagTechnology.NFC_B): + ///////////////////////////////////////////////////////////////// + // Broadcom: Since BCM2079x supports this, set NfcB max size. + //return 0; // PN544 does not support transceive of raw NfcB + return 253; // PN544 does not support transceive of raw NfcB + case (TagTechnology.NFC_V): + return 253; // PN544 RF buffer = 255 bytes, subtract two for CRC + case (TagTechnology.ISO_DEP): + /* The maximum length of a normal IsoDep frame consists of: + * CLA, INS, P1, P2, LC, LE + 255 payload bytes = 261 bytes + * such a frame is supported. Extended length frames however + * are not supported. + */ + return 261; // Will be automatically split in two frames on the RF layer + case (TagTechnology.NFC_F): + return 252; // PN544 RF buffer = 255 bytes, subtract one for SoD, two for CRC + default: + return 0; + } + + } + + private native void doSetP2pInitiatorModes(int modes); + @Override + public void setP2pInitiatorModes(int modes) { + doSetP2pInitiatorModes(modes); + } + + private native void doSetP2pTargetModes(int modes); + @Override + public void setP2pTargetModes(int modes) { + doSetP2pTargetModes(modes); + } + @Override + public boolean getExtendedLengthApdusSupported() { + // TODO check BCM support + return false; + } + + @Override + public boolean enablePN544Quirks() { + return false; + } + + @Override + public byte[][] getWipeApdus() { + return EE_WIPE_APDUS; + } + + @Override + public int getDefaultLlcpMiu() { + return DEFAULT_LLCP_MIU; + } + + @Override + public int getDefaultLlcpRwSize() { + return DEFAULT_LLCP_RWSIZE; + } + + private native String doDump(); + @Override + public String dump() { + return doDump(); + } + + /** + * Notifies Ndef Message (TODO: rename into notifyTargetDiscovered) + */ + private void notifyNdefMessageListeners(NativeNfcTag tag) { + mListener.onRemoteEndpointDiscovered(tag); + } + + /** + * Notifies transaction + */ + private void notifyTargetDeselected() { + mListener.onCardEmulationDeselected(); + } + + /** + * Notifies transaction + */ + private void notifyTransactionListeners(byte[] aid) { + mListener.onCardEmulationAidSelected(aid); + } + + /** + * Notifies P2P Device detected, to activate LLCP link + */ + private void notifyLlcpLinkActivation(NativeP2pDevice device) { + mListener.onLlcpLinkActivated(device); + } + + /** + * Notifies P2P Device detected, to activate LLCP link + */ + private void notifyLlcpLinkDeactivated(NativeP2pDevice device) { + mListener.onLlcpLinkDeactivated(device); + } + + private void notifySeFieldActivated() { + mListener.onRemoteFieldActivated(); + } + + private void notifySeFieldDeactivated() { + mListener.onRemoteFieldDeactivated(); + } + + private void notifySeListenActivated() { + mListener.onSeListenActivated(); + } + + private void notifySeListenDeactivated() { + mListener.onSeListenDeactivated(); + } + + private void notifySeApduReceived(byte[] apdu) { + mListener.onSeApduReceived(apdu); + } + + private void notifySeEmvCardRemoval() { + mListener.onSeEmvCardRemoval(); + } + + private void notifySeMifareAccess(byte[] block) { + mListener.onSeMifareAccess(block); + } + +} diff --git a/nci/src/com/android/nfc/dhimpl/NativeNfcSecureElement.java b/nci/src/com/android/nfc/dhimpl/NativeNfcSecureElement.java new file mode 100755 index 0000000..e2d91ec --- /dev/null +++ b/nci/src/com/android/nfc/dhimpl/NativeNfcSecureElement.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.nfc.dhimpl; + +import android.content.Context; +import android.content.SharedPreferences; + + +/** + * Native interface to the NFC Secure Element functions + * + * {@hide} + */ +public class NativeNfcSecureElement { + + static final String PREF_SE_WIRED = "se_wired"; + + private final Context mContext; + + SharedPreferences mPrefs; + SharedPreferences.Editor mPrefsEditor; + + public NativeNfcSecureElement(Context context) { + mContext = context; + + mPrefs = mContext.getSharedPreferences(NativeNfcManager.PREF, Context.MODE_PRIVATE); + mPrefsEditor = mPrefs.edit(); + } + + private native int doNativeOpenSecureElementConnection(); + + public int doOpenSecureElementConnection() { + mPrefsEditor.putBoolean(PREF_SE_WIRED, true); + mPrefsEditor.apply(); + + return doNativeOpenSecureElementConnection(); + } + + private native boolean doNativeDisconnectSecureElementConnection(int handle); + + public boolean doDisconnect(int handle) { + mPrefsEditor.putBoolean(PREF_SE_WIRED, false); + mPrefsEditor.apply(); + + return doNativeDisconnectSecureElementConnection(handle); + } + + public native byte[] doTransceive(int handle, byte[] data); + + public native int[] doGetTechList(int handle); + + public native byte [] doGetUid(int handle); +} diff --git a/nci/src/com/android/nfc/dhimpl/NativeNfcTag.java b/nci/src/com/android/nfc/dhimpl/NativeNfcTag.java new file mode 100755 index 0000000..eb8410f --- /dev/null +++ b/nci/src/com/android/nfc/dhimpl/NativeNfcTag.java @@ -0,0 +1,811 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.nfc.dhimpl; + +import com.android.nfc.DeviceHost.TagEndpoint; + +import android.nfc.FormatException; +import android.nfc.NdefMessage; +import android.nfc.tech.IsoDep; +import android.nfc.tech.MifareClassic; +import android.nfc.tech.MifareUltralight; +import android.nfc.tech.Ndef; +import android.nfc.tech.NfcA; +import android.nfc.tech.NfcB; +import android.nfc.tech.NfcF; +import android.nfc.tech.NfcV; +import android.nfc.tech.TagTechnology; +import android.os.Bundle; +import android.util.Log; + +/** + * Native interface to the NFC tag functions + */ +public class NativeNfcTag implements TagEndpoint { + static final boolean DBG = true; + + static final int STATUS_CODE_TARGET_LOST = 146; + + private int[] mTechList; + private int[] mTechHandles; + private int[] mTechLibNfcTypes; + private Bundle[] mTechExtras; + private byte[][] mTechPollBytes; + private byte[][] mTechActBytes; + private byte[] mUid; + + // mConnectedHandle stores the *real* libnfc handle + // that we're connected to. + private int mConnectedHandle; + + // mConnectedTechIndex stores to which technology + // the upper layer stack is connected. Note that + // we may be connected to a libnfchandle without being + // connected to a technology - technology changes + // may occur runtime, whereas the underlying handle + // could stay present. Usually all technologies are on the + // same handle, with the exception of multi-protocol + // tags. + private int mConnectedTechIndex; // Index in mTechHandles + + private final String TAG = "NativeNfcTag"; + + private boolean mIsPresent; // Whether the tag is known to be still present + + private PresenceCheckWatchdog mWatchdog; + class PresenceCheckWatchdog extends Thread { + + private int watchdogTimeout = 125; + + private boolean isPresent = true; + private boolean isStopped = false; + private boolean isPaused = false; + private boolean doCheck = true; + + public synchronized void pause() { + isPaused = true; + doCheck = false; + this.notifyAll(); + } + + public synchronized void doResume() { + isPaused = false; + // We don't want to resume presence checking immediately, + // but go through at least one more wait period. + doCheck = false; + this.notifyAll(); + } + + public synchronized void end() { + isStopped = true; + doCheck = false; + this.notifyAll(); + } + + public synchronized void setTimeout(int timeout) { + watchdogTimeout = timeout; + doCheck = false; // Do it only after we have waited "timeout" ms again + this.notifyAll(); + } + + @Override + public synchronized void run() { + if (DBG) Log.d(TAG, "Starting background presence check"); + while (isPresent && !isStopped) { + try { + if (!isPaused) { + doCheck = true; + } + this.wait(watchdogTimeout); + if (doCheck) { + isPresent = doPresenceCheck(); + } else { + // 1) We are paused, waiting for unpause + // 2) We just unpaused, do pres check in next iteration + // (after watchdogTimeout ms sleep) + // 3) We just set the timeout, wait for this timeout + // to expire once first. + // 4) We just stopped, exit loop anyway + } + } catch (InterruptedException e) { + // Activity detected, loop + } + } + mIsPresent = false; + // Restart the polling loop + + Log.d(TAG, "Tag lost, restarting polling loop"); + doDisconnect(); + if (DBG) Log.d(TAG, "Stopping background presence check"); + } + } + + private native int doConnect(int handle); + public synchronized int connectWithStatus(int technology) { + if (mWatchdog != null) { + mWatchdog.pause(); + } + int status = -1; + for (int i = 0; i < mTechList.length; i++) { + if (mTechList[i] == technology) { + // Get the handle and connect, if not already connected + if (mConnectedHandle != mTechHandles[i]) { + // We're not yet connected to this handle, there are + // a few scenario's here: + // 1) We are not connected to anything yet - allow + // 2) We are connected to a technology which has + // a different handle (multi-protocol tag); we support + // switching to that. + if (mConnectedHandle == -1) { + // Not connected yet + //status = doConnect(mTechHandles[i]); + status = doConnect(i); + } else { + // Connect to a tech with a different handle + Log.d(TAG,"Connect to a tech with a different handle"); + //status = reconnectWithStatus(mTechHandles[i]); + status = reconnectWithStatus(i); + } + if (status == 0) { + mConnectedHandle = mTechHandles[i]; + mConnectedTechIndex = i; + } + } else { + // 1) We are connected to a technology which has the same + // handle; we do not support connecting at a different + // level (libnfc auto-activates to the max level on + // any handle). + // 2) We are connecting to the ndef technology - always + // allowed. + if ((technology == TagTechnology.NDEF) || + (technology == TagTechnology.NDEF_FORMATABLE)) { + // special case for NDEF, this will cause switch to ISO_DEP frame intf + i = 0; + // status = 0; + } + status = reconnectWithStatus(i); + /* + if ((technology != TagTechnology.ISO_DEP) && + (hasTechOnHandle(TagTechnology.ISO_DEP, mTechHandles[i]))) { + // Don't allow to connect a -4 tag at a different level + // than IsoDep, as this is not supported by + // libNFC. + // revised for NFCA... do allow to connect a -4 tag at this level. + Log.d(TAG,"Connect to a tech with same different handle (rf intf change)"); + status = reconnectWithStatus(i); + if (status == 0) { + mConnectedHandle = mTechHandles[i]; + mConnectedTechIndex = i; + } + //status = 0; + } else { + status = 0; + } + */ + + + if (status == 0) { + mConnectedTechIndex = i; + // Handle was already identical + } + } + break; + } + } + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return status; + } + @Override + public synchronized boolean connect(int technology) { + return connectWithStatus(technology) == 0; + } + + @Override + public synchronized void startPresenceChecking() { + // Once we start presence checking, we allow the upper layers + // to know the tag is in the field. + mIsPresent = true; + if (mWatchdog == null) { + mWatchdog = new PresenceCheckWatchdog(); + mWatchdog.start(); + } + } + + @Override + public synchronized boolean isPresent() { + // Returns whether the tag is still in the field to the best + // of our knowledge. + return mIsPresent; + } + native boolean doDisconnect(); + @Override + public synchronized boolean disconnect() { + boolean result = false; + + mIsPresent = false; + if (mWatchdog != null) { + // Watchdog has already disconnected or will do it + mWatchdog.end(); + try { + mWatchdog.join(); + } catch (InterruptedException e) { + // Should never happen. + } + mWatchdog = null; + result = true; + } else { + result = doDisconnect(); + } + + mConnectedTechIndex = -1; + mConnectedHandle = -1; + return result; + } + + native int doReconnect(); + public synchronized int reconnectWithStatus() { + if (mWatchdog != null) { + mWatchdog.pause(); + } + int status = doReconnect(); + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return status; + } + @Override + public synchronized boolean reconnect() { + return reconnectWithStatus() == 0; + } + + native int doHandleReconnect(int handle); + public synchronized int reconnectWithStatus(int handle) { + if (mWatchdog != null) { + mWatchdog.pause(); + } + int status = doHandleReconnect(handle); + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return status; + } + + private native byte[] doTransceive(byte[] data, boolean raw, int[] returnCode); + @Override + public synchronized byte[] transceive(byte[] data, boolean raw, int[] returnCode) { + if (mWatchdog != null) { + mWatchdog.pause(); + } + byte[] result = doTransceive(data, raw, returnCode); + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return result; + } + + private native int doCheckNdef(int[] ndefinfo); + private synchronized int checkNdefWithStatus(int[] ndefinfo) { + if (mWatchdog != null) { + mWatchdog.pause(); + } + int status = doCheckNdef(ndefinfo); + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return status; + } + @Override + public synchronized boolean checkNdef(int[] ndefinfo) { + return checkNdefWithStatus(ndefinfo) == 0; + } + + private native byte[] doRead(); + @Override + public synchronized byte[] readNdef() { + if (mWatchdog != null) { + mWatchdog.pause(); + } + byte[] result = doRead(); + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return result; + } + + private native boolean doWrite(byte[] buf); + @Override + public synchronized boolean writeNdef(byte[] buf) { + if (mWatchdog != null) { + mWatchdog.pause(); + } + boolean result = doWrite(buf); + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return result; + } + + native boolean doPresenceCheck(); + @Override + public synchronized boolean presenceCheck() { + if (mWatchdog != null) { + mWatchdog.pause(); + } + boolean result = doPresenceCheck(); + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return result; + } + + native boolean doNdefFormat(byte[] key); + @Override + public synchronized boolean formatNdef(byte[] key) { + if (mWatchdog != null) { + mWatchdog.pause(); + } + boolean result = doNdefFormat(key); + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return result; + } + + native boolean doMakeReadonly(byte[] key); + @Override + public synchronized boolean makeReadOnly() { + if (mWatchdog != null) { + mWatchdog.pause(); + } + boolean result; + if (hasTech(TagTechnology.MIFARE_CLASSIC)) { + result = doMakeReadonly(MifareClassic.KEY_DEFAULT); + } else { + // No key needed for other technologies + result = doMakeReadonly(new byte[] {}); + } + if (mWatchdog != null) { + mWatchdog.doResume(); + } + return result; + } + + native boolean doIsIsoDepNdefFormatable(byte[] poll, byte[] act); + @Override + public synchronized boolean isNdefFormatable() { + // Let native code decide whether the currently activated tag + // is formatable. Although the name of the JNI function refers + // to ISO-DEP, the JNI function checks all tag types. + return doIsIsoDepNdefFormatable(mTechPollBytes[0], + mTechActBytes[0]); + } + + @Override + public int getHandle() { + // This is just a handle for the clients; it can simply use the first + // technology handle we have. + if (mTechHandles.length > 0) { + return mTechHandles[0]; + } else { + return 0; + } + } + + @Override + public byte[] getUid() { + return mUid; + } + + @Override + public int[] getTechList() { + return mTechList; + } + + private int getConnectedHandle() { + return mConnectedHandle; + } + + private int getConnectedLibNfcType() { + if (mConnectedTechIndex != -1 && mConnectedTechIndex < mTechLibNfcTypes.length) { + return mTechLibNfcTypes[mConnectedTechIndex]; + } else { + return 0; + } + } + + @Override + public int getConnectedTechnology() { + if (mConnectedTechIndex != -1 && mConnectedTechIndex < mTechList.length) { + return mTechList[mConnectedTechIndex]; + } else { + return 0; + } + } + native int doGetNdefType(int libnfctype, int javatype); + private int getNdefType(int libnfctype, int javatype) { + return doGetNdefType(libnfctype, javatype); + } + + private void addTechnology(int tech, int handle, int libnfctype) { + int[] mNewTechList = new int[mTechList.length + 1]; + System.arraycopy(mTechList, 0, mNewTechList, 0, mTechList.length); + mNewTechList[mTechList.length] = tech; + mTechList = mNewTechList; + + int[] mNewHandleList = new int[mTechHandles.length + 1]; + System.arraycopy(mTechHandles, 0, mNewHandleList, 0, mTechHandles.length); + mNewHandleList[mTechHandles.length] = handle; + mTechHandles = mNewHandleList; + + int[] mNewTypeList = new int[mTechLibNfcTypes.length + 1]; + System.arraycopy(mTechLibNfcTypes, 0, mNewTypeList, 0, mTechLibNfcTypes.length); + mNewTypeList[mTechLibNfcTypes.length] = libnfctype; + mTechLibNfcTypes = mNewTypeList; + } + + @Override + public void removeTechnology(int tech) { + synchronized (this) { + int techIndex = getTechIndex(tech); + if (techIndex != -1) { + int[] mNewTechList = new int[mTechList.length - 1]; + System.arraycopy(mTechList, 0, mNewTechList, 0, techIndex); + System.arraycopy(mTechList, techIndex + 1, mNewTechList, techIndex, + mTechList.length - techIndex - 1); + mTechList = mNewTechList; + + int[] mNewHandleList = new int[mTechHandles.length - 1]; + System.arraycopy(mTechHandles, 0, mNewHandleList, 0, techIndex); + System.arraycopy(mTechHandles, techIndex + 1, mNewTechList, techIndex, + mTechHandles.length - techIndex - 1); + mTechHandles = mNewHandleList; + + int[] mNewTypeList = new int[mTechLibNfcTypes.length - 1]; + System.arraycopy(mTechLibNfcTypes, 0, mNewTypeList, 0, techIndex); + System.arraycopy(mTechLibNfcTypes, techIndex + 1, mNewTypeList, techIndex, + mTechLibNfcTypes.length - techIndex - 1); + mTechLibNfcTypes = mNewTypeList; + + //The technology must be removed from the mTechExtras array, + //just like the above arrays. + //Remove the specified element from the array, + //then shift the remaining elements by one. + if (mTechExtras != null) + { + Bundle[] mNewTechExtras = new Bundle[mTechExtras.length - 1]; + System.arraycopy(mTechExtras, 0, mNewTechExtras, 0, techIndex); + System.arraycopy(mTechExtras, techIndex + 1, mNewTechExtras, techIndex, + mTechExtras.length - techIndex - 1); + mTechExtras = mNewTechExtras; + } + } + } + } + + public void addNdefFormatableTechnology(int handle, int libnfcType) { + synchronized (this) { + addTechnology(TagTechnology.NDEF_FORMATABLE, handle, libnfcType); + } + } + + // This method exists to "patch in" the ndef technologies, + // which is done inside Java instead of the native JNI code. + // To not create some nasty dependencies on the order on which things + // are called (most notably getTechExtras()), it needs some additional + // checking. + public void addNdefTechnology(NdefMessage msg, int handle, int libnfcType, + int javaType, int maxLength, int cardState) { + synchronized (this) { + addTechnology(TagTechnology.NDEF, handle, libnfcType); + + Bundle extras = new Bundle(); + extras.putParcelable(Ndef.EXTRA_NDEF_MSG, msg); + extras.putInt(Ndef.EXTRA_NDEF_MAXLENGTH, maxLength); + extras.putInt(Ndef.EXTRA_NDEF_CARDSTATE, cardState); + extras.putInt(Ndef.EXTRA_NDEF_TYPE, getNdefType(libnfcType, javaType)); + + if (mTechExtras == null) { + // This will build the tech extra's for the first time, + // including a NULL ref for the NDEF tech we generated above. + Bundle[] builtTechExtras = getTechExtras(); + builtTechExtras[builtTechExtras.length - 1] = extras; + } + else { + // Tech extras were built before, patch the NDEF one in + Bundle[] oldTechExtras = getTechExtras(); + Bundle[] newTechExtras = new Bundle[oldTechExtras.length + 1]; + System.arraycopy(oldTechExtras, 0, newTechExtras, 0, oldTechExtras.length); + newTechExtras[oldTechExtras.length] = extras; + mTechExtras = newTechExtras; + } + + + } + } + + private int getTechIndex(int tech) { + int techIndex = -1; + for (int i = 0; i < mTechList.length; i++) { + if (mTechList[i] == tech) { + techIndex = i; + break; + } + } + return techIndex; + } + + private boolean hasTech(int tech) { + boolean hasTech = false; + for (int i = 0; i < mTechList.length; i++) { + if (mTechList[i] == tech) { + hasTech = true; + break; + } + } + return hasTech; + } + + private boolean hasTechOnHandle(int tech, int handle) { + boolean hasTech = false; + for (int i = 0; i < mTechList.length; i++) { + if (mTechList[i] == tech && mTechHandles[i] == handle) { + hasTech = true; + break; + } + } + return hasTech; + + } + + private boolean isUltralightC() { + /* Make a best-effort attempt at classifying ULTRALIGHT + * vs ULTRALIGHT-C (based on NXP's public AN1303). + * The memory layout is as follows: + * Page # BYTE1 BYTE2 BYTE3 BYTE4 + * 2 INT1 INT2 LOCK LOCK + * 3 OTP OTP OTP OTP (NDEF CC if NDEF-formatted) + * 4 DATA DATA DATA DATA (version info if factory-state) + * + * Read four blocks from page 2, which will get us both + * the lock page, the OTP page and the version info. + */ + boolean isUltralightC = false; + byte[] readCmd = { 0x30, 0x02 }; + int[] retCode = new int[2]; + byte[] respData = transceive(readCmd, false, retCode); + if (respData != null && respData.length == 16) { + // Check the lock bits (last 2 bytes in page2) + // and the OTP bytes (entire page 3) + if (respData[2] == 0 && respData[3] == 0 && respData[4] == 0 && + respData[5] == 0 && respData[6] == 0 && respData[7] == 0) { + // Very likely to be a blank card, look at version info + // in page 4. + if ((respData[8] == (byte)0x02) && respData[9] == (byte)0x00) { + // This is Ultralight-C + isUltralightC = true; + } else { + // 0xFF 0xFF would indicate Ultralight, but we also use Ultralight + // as a fallback if it's anything else + isUltralightC = false; + } + } else { + // See if we can find the NDEF CC in the OTP page and if it's + // smaller than major version two + if (respData[4] == (byte)0xE1 && ((respData[5] & 0xff) < 0x20)) { + // OK, got NDEF. Technically we'd have to search for the + // NDEF TLV as well. However, this would add too much + // time for discovery and we can make already make a good guess + // with the data we have here. Byte 2 of the OTP page + // indicates the size of the tag - 0x06 is UL, anything + // above indicates UL-C. + if ((respData[6] & 0xff) > 0x06) { + isUltralightC = true; + } + } else { + // Fall back to ultralight + isUltralightC = false; + } + } + } + return isUltralightC; + } + + @Override + public Bundle[] getTechExtras() { + synchronized (this) { + if (mTechExtras != null) return mTechExtras; + mTechExtras = new Bundle[mTechList.length]; + for (int i = 0; i < mTechList.length; i++) { + Bundle extras = new Bundle(); + switch (mTechList[i]) { + case TagTechnology.NFC_A: { + byte[] actBytes = mTechActBytes[i]; + if ((actBytes != null) && (actBytes.length > 0)) { + extras.putShort(NfcA.EXTRA_SAK, (short) (actBytes[0] & (short) 0xFF)); + } else { + // Unfortunately Jewel doesn't have act bytes, + // ignore this case. + } + extras.putByteArray(NfcA.EXTRA_ATQA, mTechPollBytes[i]); + break; + } + + case TagTechnology.NFC_B: { + // What's returned from the PN544 is actually: + // 4 bytes app data + // 3 bytes prot info + byte[] appData = new byte[4]; + byte[] protInfo = new byte[3]; + if (mTechPollBytes[i].length >= 7) { + System.arraycopy(mTechPollBytes[i], 0, appData, 0, 4); + System.arraycopy(mTechPollBytes[i], 4, protInfo, 0, 3); + + extras.putByteArray(NfcB.EXTRA_APPDATA, appData); + extras.putByteArray(NfcB.EXTRA_PROTINFO, protInfo); + } + break; + } + + case TagTechnology.NFC_F: { + byte[] pmm = new byte[8]; + byte[] sc = new byte[2]; + if (mTechPollBytes[i].length >= 8) { + // At least pmm is present + System.arraycopy(mTechPollBytes[i], 0, pmm, 0, 8); + extras.putByteArray(NfcF.EXTRA_PMM, pmm); + } + if (mTechPollBytes[i].length == 10) { + System.arraycopy(mTechPollBytes[i], 8, sc, 0, 2); + extras.putByteArray(NfcF.EXTRA_SC, sc); + } + break; + } + + case TagTechnology.ISO_DEP: { + if (hasTech(TagTechnology.NFC_A)) { + extras.putByteArray(IsoDep.EXTRA_HIST_BYTES, mTechActBytes[i]); + } + else { + extras.putByteArray(IsoDep.EXTRA_HI_LAYER_RESP, mTechActBytes[i]); + } + break; + } + + case TagTechnology.NFC_V: { + // First byte response flags, second byte DSFID + if (mTechPollBytes[i] != null && mTechPollBytes[i].length >= 2) { + extras.putByte(NfcV.EXTRA_RESP_FLAGS, mTechPollBytes[i][0]); + extras.putByte(NfcV.EXTRA_DSFID, mTechPollBytes[i][1]); + } + break; + } + + case TagTechnology.MIFARE_ULTRALIGHT: { + boolean isUlc = isUltralightC(); + extras.putBoolean(MifareUltralight.EXTRA_IS_UL_C, isUlc); + break; + } + + default: { + // Leave the entry in the array null + continue; + } + } + mTechExtras[i] = extras; + } + return mTechExtras; + } + } + + @Override + public NdefMessage findAndReadNdef() { + // Try to find NDEF on any of the technologies. + int[] technologies = getTechList(); + int[] handles = mTechHandles; + NdefMessage ndefMsg = null; + boolean foundFormattable = false; + int formattableHandle = 0; + int formattableLibNfcType = 0; + int status; + + for (int techIndex = 0; techIndex < technologies.length; techIndex++) { + // have we seen this handle before? + for (int i = 0; i < techIndex; i++) { + if (handles[i] == handles[techIndex]) { + continue; // don't check duplicate handles + } + } + + status = connectWithStatus(technologies[techIndex]); + if (status != 0) { + Log.d(TAG, "Connect Failed - status = "+ status); + if (status == STATUS_CODE_TARGET_LOST) { + break; + } + continue; // try next handle + } + // Check if this type is NDEF formatable + if (!foundFormattable) { + if (isNdefFormatable()) { + foundFormattable = true; + formattableHandle = getConnectedHandle(); + formattableLibNfcType = getConnectedLibNfcType(); + // We'll only add formattable tech if no ndef is + // found - this is because libNFC refuses to format + // an already NDEF formatted tag. + } + reconnect(); + } + + int[] ndefinfo = new int[2]; + status = checkNdefWithStatus(ndefinfo); + if (status != 0) { + Log.d(TAG, "Check NDEF Failed - status = " + status); + if (status == STATUS_CODE_TARGET_LOST) { + break; + } + continue; // try next handle + } + + // found our NDEF handle + boolean generateEmptyNdef = false; + + int supportedNdefLength = ndefinfo[0]; + int cardState = ndefinfo[1]; + byte[] buff = readNdef(); + if (buff != null) { + try { + ndefMsg = new NdefMessage(buff); + addNdefTechnology(ndefMsg, + getConnectedHandle(), + getConnectedLibNfcType(), + getConnectedTechnology(), + supportedNdefLength, cardState); + reconnect(); + } catch (FormatException e) { + // Create an intent anyway, without NDEF messages + generateEmptyNdef = true; + } + } else { + generateEmptyNdef = true; + } + + if (generateEmptyNdef) { + ndefMsg = null; + addNdefTechnology(null, + getConnectedHandle(), + getConnectedLibNfcType(), + getConnectedTechnology(), + supportedNdefLength, cardState); + reconnect(); + } + break; + } + + if (ndefMsg == null && foundFormattable) { + // Tag is not NDEF yet, and found a formattable target, + // so add formattable tech to tech list. + addNdefFormatableTechnology( + formattableHandle, + formattableLibNfcType); + } + + return ndefMsg; + } +} diff --git a/nci/src/com/android/nfc/dhimpl/NativeP2pDevice.java b/nci/src/com/android/nfc/dhimpl/NativeP2pDevice.java new file mode 100755 index 0000000..094f46a --- /dev/null +++ b/nci/src/com/android/nfc/dhimpl/NativeP2pDevice.java @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.nfc.dhimpl; + +import com.android.nfc.DeviceHost.NfcDepEndpoint; + +/** + * Native interface to the P2P Initiator functions + */ +public class NativeP2pDevice implements NfcDepEndpoint { + + private int mHandle; + + private int mMode; + + private byte[] mGeneralBytes; + + private native byte[] doReceive(); + @Override + public byte[] receive() { + return doReceive(); + } + + private native boolean doSend(byte[] data); + @Override + public boolean send(byte[] data) { + return doSend(data); + } + + private native boolean doConnect(); + @Override + public boolean connect() { + return doConnect(); + } + + private native boolean doDisconnect(); + @Override + public boolean disconnect() { + return doDisconnect(); + } + + public native byte[] doTransceive(byte[] data); + @Override + public byte[] transceive(byte[] data) { + return doTransceive(data); + } + + @Override + public int getHandle() { + return mHandle; + } + + @Override + public int getMode() { + return mMode; + } + + @Override + public byte[] getGeneralBytes() { + return mGeneralBytes; + } + +} diff --git a/nxp/src/com/android/nfc/dhimpl/NativeNfcManager.java b/nxp/src/com/android/nfc/dhimpl/NativeNfcManager.java index f969627..dc6ea7c 100755 --- a/nxp/src/com/android/nfc/dhimpl/NativeNfcManager.java +++ b/nxp/src/com/android/nfc/dhimpl/NativeNfcManager.java @@ -43,6 +43,25 @@ public class NativeNfcManager implements DeviceHost { private static final String PREF_FIRMWARE_MODTIME = "firmware_modtime"; private static final long FIRMWARE_MODTIME_DEFAULT = -1; + static final String DRIVER_NAME = "nxp"; + + static final int DEFAULT_LLCP_MIU = 128; + static final int DEFAULT_LLCP_RWSIZE = 1; + + //TODO: dont hardcode this + private static final byte[][] EE_WIPE_APDUS = { + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x07, (byte)0xa0, (byte)0x00, + (byte)0x00, (byte)0x04, (byte)0x76, (byte)0x20, (byte)0x10, (byte)0x00}, + {(byte)0x80, (byte)0xe2, (byte)0x01, (byte)0x03, (byte)0x00}, + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x07, (byte)0xa0, (byte)0x00, + (byte)0x00, (byte)0x04, (byte)0x76, (byte)0x30, (byte)0x30, (byte)0x00}, + {(byte)0x80, (byte)0xb4, (byte)0x00, (byte)0x00, (byte)0x00}, + {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, + }; + + static { System.loadLibrary("nfc_jni"); } @@ -144,6 +163,11 @@ public class NativeNfcManager implements DeviceHost { } @Override + public String getName() { + return DRIVER_NAME; + } + + @Override public native void enableDiscovery(); @Override @@ -305,11 +329,32 @@ public class NativeNfcManager implements DeviceHost { doSetP2pTargetModes(modes); } + @Override public boolean getExtendedLengthApdusSupported() { // Not supported on the PN544 return false; } + @Override + public boolean enablePN544Quirks() { + return true; + } + + @Override + public byte[][] getWipeApdus() { + return EE_WIPE_APDUS; + } + + @Override + public int getDefaultLlcpMiu() { + return DEFAULT_LLCP_MIU; + } + + @Override + public int getDefaultLlcpRwSize() { + return DEFAULT_LLCP_RWSIZE; + } + private native String doDump(); @Override public String dump() { @@ -370,4 +415,5 @@ public class NativeNfcManager implements DeviceHost { private void notifySeMifareAccess(byte[] block) { mListener.onSeMifareAccess(block); } + } diff --git a/nxp/src/com/android/nfc/dhimpl/NativeNfcTag.java b/nxp/src/com/android/nfc/dhimpl/NativeNfcTag.java index eddde94..992e6d2 100755 --- a/nxp/src/com/android/nfc/dhimpl/NativeNfcTag.java +++ b/nxp/src/com/android/nfc/dhimpl/NativeNfcTag.java @@ -136,6 +136,10 @@ public class NativeNfcTag implements TagEndpoint { private native int doConnect(int handle); public synchronized int connectWithStatus(int technology) { + if (technology == TagTechnology.NFC_B) { + // Not supported by PN544 + return -1; + } if (mWatchdog != null) { mWatchdog.pause(); } @@ -785,6 +789,7 @@ public class NativeNfcTag implements TagEndpoint { getConnectedLibNfcType(), getConnectedTechnology(), supportedNdefLength, cardState); + foundFormattable = false; reconnect(); } break; diff --git a/src/com/android/nfc/DeviceHost.java b/src/com/android/nfc/DeviceHost.java index 047e3d5..e514bb6 100644 --- a/src/com/android/nfc/DeviceHost.java +++ b/src/com/android/nfc/DeviceHost.java @@ -49,6 +49,16 @@ public interface DeviceHost { public void onRemoteFieldDeactivated(); + /** + * Notifies that the SE has been activated in listen mode + */ + public void onSeListenActivated(); + + /** + * Notifies that the SE has been deactivated + */ + public void onSeListenDeactivated(); + public void onSeApduReceived(byte[] apdu); public void onSeEmvCardRemoval(); @@ -175,6 +185,8 @@ public interface DeviceHost { public boolean deinitialize(); + public String getName(); + public void enableDiscovery(); public void disableDiscovery(); @@ -216,5 +228,13 @@ public interface DeviceHost { boolean getExtendedLengthApdusSupported(); + boolean enablePN544Quirks(); + + byte[][] getWipeApdus(); + + int getDefaultLlcpMiu(); + + int getDefaultLlcpRwSize(); + String dump(); } diff --git a/src/com/android/nfc/FireflyRenderer.java b/src/com/android/nfc/FireflyRenderer.java index 4ce58b4..40c931d 100644 --- a/src/com/android/nfc/FireflyRenderer.java +++ b/src/com/android/nfc/FireflyRenderer.java @@ -200,6 +200,7 @@ public class FireflyRenderer { for (int i = 0; i < 3; i++) { // Call eglSwapBuffers 3 times - this will allocate the necessary // buffers, and make sure the animation looks smooth from the start. + mGL.glClear(GL10.GL_COLOR_BUFFER_BIT); if (!mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) { Log.e(LOG_TAG, "Could not swap buffers"); mFinished = true; diff --git a/src/com/android/nfc/NfcApplication.java b/src/com/android/nfc/NfcApplication.java new file mode 100644 index 0000000..867b8bb --- /dev/null +++ b/src/com/android/nfc/NfcApplication.java @@ -0,0 +1,24 @@ +package com.android.nfc; + +import android.app.Application; +import android.os.UserHandle; +import android.util.Log; + +public class NfcApplication extends Application { + + public static final String TAG = "NfcApplication"; + NfcService mNfcService; + + public NfcApplication() { + + } + + @Override + public void onCreate() { + super.onCreate(); + + if (UserHandle.myUserId() == 0) { + mNfcService = new NfcService(this); + } + } +} diff --git a/src/com/android/nfc/NfcDispatcher.java b/src/com/android/nfc/NfcDispatcher.java index b3ab97c..1721d1a 100644 --- a/src/com/android/nfc/NfcDispatcher.java +++ b/src/com/android/nfc/NfcDispatcher.java @@ -20,6 +20,7 @@ import com.android.nfc.RegisteredComponentCache.ComponentInfo; import com.android.nfc.handover.HandoverManager; import android.app.Activity; +import android.app.ActivityManager; import android.app.ActivityManagerNative; import android.app.IActivityManager; import android.app.PendingIntent; @@ -30,6 +31,7 @@ import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; import android.content.pm.ResolveInfo; import android.net.Uri; import android.nfc.NdefMessage; @@ -38,6 +40,7 @@ import android.nfc.NfcAdapter; import android.nfc.Tag; import android.nfc.tech.Ndef; import android.os.RemoteException; +import android.os.UserHandle; import android.util.Log; import java.io.FileDescriptor; @@ -58,7 +61,6 @@ public class NfcDispatcher { final Context mContext; final IActivityManager mIActivityManager; final RegisteredComponentCache mTechListFilters; - final PackageManager mPackageManager; final ContentResolver mContentResolver; final HandoverManager mHandoverManager; @@ -72,7 +74,6 @@ public class NfcDispatcher { mIActivityManager = ActivityManagerNative.getDefault(); mTechListFilters = new RegisteredComponentCache(mContext, NfcAdapter.ACTION_TECH_DISCOVERED, NfcAdapter.ACTION_TECH_DISCOVERED); - mPackageManager = context.getPackageManager(); mContentResolver = context.getContentResolver(); mHandoverManager = handoverManager; } @@ -157,19 +158,21 @@ public class NfcDispatcher { // is not available on Context. Instead, we query the PackageManager beforehand // to determine if there is an Activity to handle this intent, and base the // result of off that. - List activities = packageManager.queryIntentActivities(intent, 0); + List activities = packageManager.queryIntentActivitiesAsUser(intent, 0, + ActivityManager.getCurrentUser()); if (activities.size() > 0) { - context.startActivity(rootIntent); + context.startActivityAsUser(rootIntent, UserHandle.CURRENT); return true; } return false; } boolean tryStartActivity(Intent intentToStart) { - List activities = packageManager.queryIntentActivities(intentToStart, 0); + List activities = packageManager.queryIntentActivitiesAsUser( + intentToStart, 0, ActivityManager.getCurrentUser()); if (activities.size() > 0) { rootIntent.putExtra(NfcRootActivity.EXTRA_LAUNCH_INTENT, intentToStart); - context.startActivity(rootIntent); + context.startActivityAsUser(rootIntent, UserHandle.CURRENT); return true; } return false; @@ -305,7 +308,10 @@ public class NfcDispatcher { if (message == null) { return false; } - dispatch.setNdefIntent(); + Intent intent = dispatch.setNdefIntent(); + + // Bail out if the intent does not contain filterable NDEF data + if (intent == null) return false; // Try to start AAR activity with matching filter List aarPackages = extractAarPackages(message); @@ -320,7 +326,16 @@ public class NfcDispatcher { // Try to perform regular launch of the first AAR if (aarPackages.size() > 0) { String firstPackage = aarPackages.get(0); - Intent appLaunchIntent = mPackageManager.getLaunchIntentForPackage(firstPackage); + PackageManager pm; + try { + UserHandle currentUser = new UserHandle(ActivityManager.getCurrentUser()); + pm = mContext.createPackageContextAsUser("android", 0, + currentUser).getPackageManager(); + } catch (NameNotFoundException e) { + Log.e(TAG, "Could not create user package context"); + return false; + } + Intent appLaunchIntent = pm.getLaunchIntentForPackage(firstPackage); if (appLaunchIntent != null && dispatch.tryStartActivity(appLaunchIntent)) { if (DBG) Log.i(TAG, "matched AAR to application launch"); return true; @@ -364,11 +379,20 @@ public class NfcDispatcher { ArrayList matches = new ArrayList(); List registered = mTechListFilters.getComponents(); + PackageManager pm; + try { + UserHandle currentUser = new UserHandle(ActivityManager.getCurrentUser()); + pm = mContext.createPackageContextAsUser("android", 0, + currentUser).getPackageManager(); + } catch (NameNotFoundException e) { + Log.e(TAG, "Could not create user package context"); + return false; + } // Check each registered activity to see if it matches for (ComponentInfo info : registered) { // Don't allow wild card matching if (filterMatch(tagTechs, info.techs) && - isComponentEnabled(mPackageManager, info.resolveInfo)) { + isComponentEnabled(pm, info.resolveInfo)) { // Add the activity as a match if it's not already in the list if (!matches.contains(info.resolveInfo)) { matches.add(info.resolveInfo); diff --git a/src/com/android/nfc/NfcRootActivity.java b/src/com/android/nfc/NfcRootActivity.java index 1325ead..cc216f2 100644 --- a/src/com/android/nfc/NfcRootActivity.java +++ b/src/com/android/nfc/NfcRootActivity.java @@ -17,9 +17,11 @@ package com.android.nfc; import android.app.Activity; +import android.app.ActivityManager; import android.content.ActivityNotFoundException; import android.content.Intent; import android.os.Bundle; +import android.os.UserHandle; public class NfcRootActivity extends Activity { @@ -33,7 +35,7 @@ public class NfcRootActivity extends Activity { final Intent launchIntent = intent.getParcelableExtra(EXTRA_LAUNCH_INTENT); if (launchIntent != null) { try { - startActivity(launchIntent); + startActivityAsUser(launchIntent, UserHandle.CURRENT); } catch (ActivityNotFoundException e) { } } diff --git a/src/com/android/nfc/NfcService.java b/src/com/android/nfc/NfcService.java index 3e7a6b5..d63f84f 100755 --- a/src/com/android/nfc/NfcService.java +++ b/src/com/android/nfc/NfcService.java @@ -63,6 +63,7 @@ import android.os.PowerManager; import android.os.Process; import android.os.RemoteException; import android.os.ServiceManager; +import android.os.UserHandle; import android.provider.Settings; import android.util.Log; @@ -75,7 +76,7 @@ import java.util.HashSet; import java.util.List; import java.util.concurrent.ExecutionException; -public class NfcService extends Application implements DeviceHostListener { +public class NfcService implements DeviceHostListener { private static final String ACTION_MASTER_CLEAR_NOTIFICATION = "android.intent.action.MASTER_CLEAR_NOTIFICATION"; static final boolean DBG = false; @@ -101,8 +102,6 @@ public class NfcService extends Application implements DeviceHostListener { static final String PREF_FIRST_BOOT = "first_boot"; static final String PREF_AIRPLANE_OVERRIDE = "airplane_override"; - static final boolean PN544_QUIRK_DISCONNECT_BEFORE_RECONFIGURE = true; - static final int MSG_NDEF_TAG = 0; static final int MSG_CARD_EMULATION = 1; static final int MSG_LLCP_LINK_ACTIVATION = 2; @@ -114,6 +113,8 @@ public class NfcService extends Application implements DeviceHostListener { static final int MSG_SE_APDU_RECEIVED = 10; static final int MSG_SE_EMV_CARD_REMOVAL = 11; static final int MSG_SE_MIFARE_ACCESS = 12; + static final int MSG_SE_LISTEN_ACTIVATED = 13; + static final int MSG_SE_LISTEN_DEACTIVATED = 14; static final int TASK_ENABLE = 1; static final int TASK_DISABLE = 2; @@ -134,6 +135,15 @@ public class NfcService extends Application implements DeviceHostListener { /** minimum screen state that enables NFC polling (discovery) */ static final int POLLING_MODE = SCREEN_STATE_ON_UNLOCKED; + // Time to wait for NFC controller to initialize before watchdog + // goes off. This time is chosen large, because firmware download + // may be a part of initialization. + static final int INIT_WATCHDOG_MS = 90000; + + // Time to wait for routing to be applied before watchdog + // goes off + static final int ROUTING_WATCHDOG_MS = 10000; + // for use with playSound() public static final int SOUND_START = 0; public static final int SOUND_END = 1; @@ -160,18 +170,10 @@ public class NfcService extends Application implements DeviceHostListener { public static final String EXTRA_MIFARE_BLOCK = "com.android.nfc_extras.extra.MIFARE_BLOCK"; - //TODO: dont hardcode this - private static final byte[][] EE_WIPE_APDUS = { - {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, - {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x07, (byte)0xa0, (byte)0x00, - (byte)0x00, (byte)0x04, (byte)0x76, (byte)0x20, (byte)0x10, (byte)0x00}, - {(byte)0x80, (byte)0xe2, (byte)0x01, (byte)0x03, (byte)0x00}, - {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, - {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x07, (byte)0xa0, (byte)0x00, - (byte)0x00, (byte)0x04, (byte)0x76, (byte)0x30, (byte)0x30, (byte)0x00}, - {(byte)0x80, (byte)0xb4, (byte)0x00, (byte)0x00, (byte)0x00}, - {(byte)0x00, (byte)0xa4, (byte)0x04, (byte)0x00, (byte)0x00}, - }; + public static final String ACTION_SE_LISTEN_ACTIVATED = + "com.android.nfc_extras.action.SE_LISTEN_ACTIVATED"; + public static final String ACTION_SE_LISTEN_DEACTIVATED = + "com.android.nfc_extras.action.SE_LISTEN_DEACTIVATED"; // NFC Execution Environment // fields below are protected by this @@ -184,6 +186,8 @@ public class NfcService extends Application implements DeviceHostListener { // fields below are used in multiple threads and protected by synchronized(this) final HashMap mObjectMap = new HashMap(); + // mSePackages holds packages that accessed the SE, but only for the owner user, + // as SE access is not granted for non-owner users. HashSet mSePackages = new HashSet(); int mScreenState; boolean mIsNdefPushEnabled; @@ -201,7 +205,9 @@ public class NfcService extends Application implements DeviceHostListener { private DeviceHost mDeviceHost; private SharedPreferences mPrefs; private SharedPreferences.Editor mPrefsEditor; - private PowerManager.WakeLock mWakeLock; + private PowerManager.WakeLock mRoutingWakeLock; + private PowerManager.WakeLock mEeWakeLock; + int mStartSound; int mEndSound; int mErrorSound; @@ -233,6 +239,9 @@ public class NfcService extends Application implements DeviceHostListener { throw new SecurityException(NfceeAccessControl.NFCEE_ACCESS_PATH + " denies NFCEE access to " + pkg); } + if (UserHandle.getCallingUserId() != UserHandle.USER_OWNER) { + throw new SecurityException("only the owner is allowed to call SE APIs"); + } } public static NfcService getInstance() { @@ -287,6 +296,17 @@ public class NfcService extends Application implements DeviceHostListener { } @Override + public void onSeListenActivated() { + sendMessage(NfcService.MSG_SE_LISTEN_ACTIVATED, null); + } + + @Override + public void onSeListenDeactivated() { + sendMessage(NfcService.MSG_SE_LISTEN_DEACTIVATED, null); + } + + + @Override public void onSeApduReceived(byte[] apdu) { sendMessage(NfcService.MSG_SE_APDU_RECEIVED, apdu); } @@ -301,10 +321,7 @@ public class NfcService extends Application implements DeviceHostListener { sendMessage(NfcService.MSG_SE_MIFARE_ACCESS, block); } - @Override - public void onCreate() { - super.onCreate(); - + public NfcService(Application nfcApplication) { mNfcTagService = new TagService(); mNfcAdapter = new NfcAdapterService(); mExtrasService = new NfcAdapterExtrasService(); @@ -313,48 +330,60 @@ public class NfcService extends Application implements DeviceHostListener { sService = this; - mContext = this; - mDeviceHost = new NativeNfcManager(this, this); + mContext = nfcApplication; + mDeviceHost = new NativeNfcManager(mContext, this); HandoverManager handoverManager = new HandoverManager(mContext); - mNfcDispatcher = new NfcDispatcher(this, handoverManager); - mP2pLinkManager = new P2pLinkManager(mContext, handoverManager); + mNfcDispatcher = new NfcDispatcher(mContext, handoverManager); + + mP2pLinkManager = new P2pLinkManager(mContext, handoverManager, + mDeviceHost.getDefaultLlcpMiu(), mDeviceHost.getDefaultLlcpRwSize()); mSecureElement = new NativeNfcSecureElement(mContext); mEeRoutingState = ROUTE_OFF; - mNfceeAccessControl = new NfceeAccessControl(this); + mNfceeAccessControl = new NfceeAccessControl(mContext); - mPrefs = getSharedPreferences(PREF, Context.MODE_PRIVATE); + mPrefs = mContext.getSharedPreferences(PREF, Context.MODE_PRIVATE); mPrefsEditor = mPrefs.edit(); mState = NfcAdapter.STATE_OFF; mIsNdefPushEnabled = mPrefs.getBoolean(PREF_NDEF_PUSH_ON, NDEF_PUSH_ON_DEFAULT); - mPowerManager = (PowerManager) getSystemService(Context.POWER_SERVICE); + mPowerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); + + mRoutingWakeLock = mPowerManager.newWakeLock( + PowerManager.PARTIAL_WAKE_LOCK, "NfcService:mRoutingWakeLock"); + mEeWakeLock = mPowerManager.newWakeLock( + PowerManager.PARTIAL_WAKE_LOCK, "NfcService:mEeWakeLock"); - mWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "NfcService"); - mKeyguard = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE); + mKeyguard = (KeyguardManager) mContext.getSystemService(Context.KEYGUARD_SERVICE); mScreenState = checkScreenState(); ServiceManager.addService(SERVICE_NAME, mNfcAdapter); + // Intents only for owner + IntentFilter ownerFilter = new IntentFilter(NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION); + ownerFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE); + ownerFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); + ownerFilter.addAction(ACTION_MASTER_CLEAR_NOTIFICATION); + + mContext.registerReceiver(mOwnerReceiver, ownerFilter); + + ownerFilter = new IntentFilter(); + ownerFilter.addAction(Intent.ACTION_PACKAGE_ADDED); + ownerFilter.addAction(Intent.ACTION_PACKAGE_REMOVED); + ownerFilter.addDataScheme("package"); + + mContext.registerReceiver(mOwnerReceiver, ownerFilter); + + // Intents for all users IntentFilter filter = new IntentFilter(NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION); filter.addAction(Intent.ACTION_SCREEN_OFF); filter.addAction(Intent.ACTION_SCREEN_ON); - filter.addAction(ACTION_MASTER_CLEAR_NOTIFICATION); filter.addAction(Intent.ACTION_USER_PRESENT); - filter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE); - filter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); registerForAirplaneMode(filter); - registerReceiver(mReceiver, filter); - - filter = new IntentFilter(); - filter.addAction(Intent.ACTION_PACKAGE_ADDED); - filter.addAction(Intent.ACTION_PACKAGE_REMOVED); - filter.addDataScheme("package"); - - registerReceiver(mReceiver, filter); + mContext.registerReceiverAsUser(mReceiver, UserHandle.ALL, filter, null, null); updatePackageCache(); @@ -365,9 +394,9 @@ public class NfcService extends Application implements DeviceHostListener { synchronized(this) { if (mSoundPool == null) { mSoundPool = new SoundPool(1, AudioManager.STREAM_NOTIFICATION, 0); - mStartSound = mSoundPool.load(this, R.raw.start, 1); - mEndSound = mSoundPool.load(this, R.raw.end, 1); - mErrorSound = mSoundPool.load(this, R.raw.error, 1); + mStartSound = mSoundPool.load(mContext, R.raw.start, 1); + mEndSound = mSoundPool.load(mContext, R.raw.end, 1); + mErrorSound = mSoundPool.load(mContext, R.raw.error, 1); } } } @@ -399,8 +428,8 @@ public class NfcService extends Application implements DeviceHostListener { } void updatePackageCache() { - PackageManager pm = getPackageManager(); - List packages = pm.getInstalledPackages(0); + PackageManager pm = mContext.getPackageManager(); + List packages = pm.getInstalledPackages(0, UserHandle.USER_OWNER); synchronized (this) { mInstalledPackages = packages; } @@ -416,6 +445,37 @@ public class NfcService extends Application implements DeviceHostListener { } } + int doOpenSecureElementConnection() { + mEeWakeLock.acquire(); + try { + return mSecureElement.doOpenSecureElementConnection(); + } finally { + mEeWakeLock.release(); + } + } + + byte[] doTransceive(int handle, byte[] cmd) { + mEeWakeLock.acquire(); + try { + return doTransceiveNoLock(handle, cmd); + } finally { + mEeWakeLock.release(); + } + } + + byte[] doTransceiveNoLock(int handle, byte[] cmd) { + return mSecureElement.doTransceive(handle, cmd); + } + + void doDisconnect(int handle) { + mEeWakeLock.acquire(); + try { + mSecureElement.doDisconnect(handle); + } finally { + mEeWakeLock.release(); + } + } + /** * Manages tasks that involve turning on/off the NFC controller. * @@ -512,11 +572,21 @@ public class NfcService extends Application implements DeviceHostListener { Log.i(TAG, "Enabling NFC"); updateState(NfcAdapter.STATE_TURNING_ON); - - if (!mDeviceHost.initialize()) { - Log.w(TAG, "Error enabling NFC"); - updateState(NfcAdapter.STATE_OFF); - return false; + WatchDogThread watchDog = new WatchDogThread("enableInternal", INIT_WATCHDOG_MS); + watchDog.start(); + try { + mRoutingWakeLock.acquire(); + try { + if (!mDeviceHost.initialize()) { + Log.w(TAG, "Error enabling NFC"); + updateState(NfcAdapter.STATE_OFF); + return false; + } + } finally { + mRoutingWakeLock.release(); + } + } finally { + watchDog.cancel(); } synchronized(NfcService.this) { @@ -549,7 +619,7 @@ public class NfcService extends Application implements DeviceHostListener { * Implemented with a new thread (instead of a Handler or AsyncTask), * because the UI Thread and AsyncTask thread-pools can also get hung * when the NFC controller stops responding */ - WatchDogThread watchDog = new WatchDogThread(); + WatchDogThread watchDog = new WatchDogThread("disableInternal", ROUTING_WATCHDOG_MS); watchDog.start(); mP2pLinkManager.enableDisable(false, false); @@ -566,7 +636,6 @@ public class NfcService extends Application implements DeviceHostListener { // A convenient way to stop the watchdog properly consists of // disconnecting the tag. The polling loop shall be stopped before // to avoid the tag being discovered again. - applyRouting(true); maybeDisconnectTarget(); mNfcDispatcher.setForegroundDispatch(null, null, null); @@ -585,41 +654,64 @@ public class NfcService extends Application implements DeviceHostListener { void executeEeWipe() { // TODO: read SE reset list from /system/etc - byte[][]apdus = EE_WIPE_APDUS; + byte[][]apdus = mDeviceHost.getWipeApdus(); + + if (apdus == null) { + Log.d(TAG, "No wipe APDUs found"); + return; + } boolean tempEnable = mState == NfcAdapter.STATE_OFF; - if (tempEnable) { - if (!enableInternal()) { + // Hold a wake-lock over the entire wipe procedure + mEeWakeLock.acquire(); + try { + if (tempEnable && !enableInternal()) { Log.w(TAG, "Could not enable NFC to wipe NFC-EE"); return; } - } - Log.i(TAG, "Executing SE wipe"); - int handle = mSecureElement.doOpenSecureElementConnection(); - if (handle == 0) { - Log.w(TAG, "Could not open the secure element"); - if (tempEnable) { - disableInternal(); - } - return; - } - - mDeviceHost.setTimeout(TagTechnology.ISO_DEP, 10000); + try { + // NFC enabled + int handle = 0; + try { + Log.i(TAG, "Executing SE wipe"); + handle = doOpenSecureElementConnection(); + if (handle == 0) { + Log.w(TAG, "Could not open the secure element"); + return; + } + // TODO: remove this hack + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + // Ignore + } - for (byte[] cmd : apdus) { - byte[] resp = mSecureElement.doTransceive(handle, cmd); - if (resp == null) { - Log.w(TAG, "Transceive failed, could not wipe NFC-EE"); - break; + mDeviceHost.setTimeout(TagTechnology.ISO_DEP, 10000); + try { + for (byte[] cmd : apdus) { + byte[] resp = doTransceiveNoLock(handle, cmd); + if (resp == null) { + Log.w(TAG, "Transceive failed, could not wipe NFC-EE"); + break; + } + } + } finally { + mDeviceHost.resetTimeouts(); + } + } finally { + if (handle != 0) { + doDisconnect(handle); + } + } + } finally { + if (tempEnable) { + disableInternal(); + } } + } finally { + mEeWakeLock.release(); } - - mDeviceHost.resetTimeouts(); - mSecureElement.doDisconnect(handle); - - if (tempEnable) { - disableInternal(); - } + Log.i(TAG, "SE wipe done"); } void updateState(int newState) { @@ -631,7 +723,7 @@ public class NfcService extends Application implements DeviceHostListener { Intent intent = new Intent(NfcAdapter.ACTION_ADAPTER_STATE_CHANGED); intent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); intent.putExtra(NfcAdapter.EXTRA_ADAPTER_STATE, mState); - mContext.sendBroadcast(intent); + mContext.sendBroadcastAsUser(intent, UserHandle.CURRENT); } } } @@ -663,12 +755,6 @@ public class NfcService extends Application implements DeviceHostListener { } } - @Override - public void onTerminate() { - super.onTerminate(); - // NFC application is persistent, it should not be destroyed by framework - Log.wtf(TAG, "NFC service is under attack!"); - } final class NfcAdapterService extends INfcAdapter.Stub { @Override @@ -870,10 +956,6 @@ public class NfcService extends Application implements DeviceHostListener { return ErrorCodes.ERROR_DISCONNECT; } - if (technology == TagTechnology.NFC_B) { - return ErrorCodes.ERROR_NOT_SUPPORTED; - } - // Note that on most tags, all technologies are behind a single // handle. This means that the connect at the lower levels // will do nothing, as the tag is already connected to that handle. @@ -1201,7 +1283,7 @@ public class NfcService extends Application implements DeviceHostListener { binder.unlinkToDeath(mOpenEe, 0); mDeviceHost.resetTimeouts(); - mSecureElement.doDisconnect(mOpenEe.handle); + doDisconnect(mOpenEe.handle); mOpenEe = null; applyRouting(true); @@ -1244,11 +1326,11 @@ public class NfcService extends Application implements DeviceHostListener { throw new IOException("NFC EE already open"); } - int handle = mSecureElement.doOpenSecureElementConnection(); + int handle = doOpenSecureElementConnection(); if (handle == 0) { throw new IOException("NFC EE failed to open"); } - mDeviceHost.setTimeout(TagTechnology.ISO_DEP, 10000); + mDeviceHost.setTimeout(TagTechnology.ISO_DEP, 30000); mOpenEe = new OpenSecureElement(getCallingPid(), handle, b); try { @@ -1259,7 +1341,7 @@ public class NfcService extends Application implements DeviceHostListener { // Add the calling package to the list of packages that have accessed // the secure element. - for (String packageName : getPackageManager().getPackagesForUid(getCallingUid())) { + for (String packageName : mContext.getPackageManager().getPackagesForUid(getCallingUid())) { mSePackages.add(packageName); } } @@ -1308,7 +1390,7 @@ public class NfcService extends Application implements DeviceHostListener { } } - return mSecureElement.doTransceive(mOpenEe.handle, data); + return doTransceive(mOpenEe.handle, data); } @Override @@ -1321,13 +1403,28 @@ public class NfcService extends Application implements DeviceHostListener { public void setCardEmulationRoute(String pkg, int route) throws RemoteException { NfcService.this.enforceNfceeAdminPerm(pkg); mEeRoutingState = route; - applyRouting(true); + ApplyRoutingTask applyRoutingTask = new ApplyRoutingTask(); + applyRoutingTask.execute(); + try { + // Block until route is set + applyRoutingTask.get(); + } catch (ExecutionException e) { + Log.e(TAG, "failed to set card emulation mode"); + } catch (InterruptedException e) { + Log.e(TAG, "failed to set card emulation mode"); + } } @Override public void authenticate(String pkg, byte[] token) throws RemoteException { NfcService.this.enforceNfceeAdminPerm(pkg); } + + @Override + public String getDriverName(String pkg) throws RemoteException { + NfcService.this.enforceNfceeAdminPerm(pkg); + return mDeviceHost.getName(); + } } /** resources kept while secure element is open */ @@ -1376,19 +1473,27 @@ public class NfcService extends Application implements DeviceHostListener { class WatchDogThread extends Thread { boolean mWatchDogCanceled = false; + final int mTimeout; + + public WatchDogThread(String threadName, int timeout) { + super(threadName); + mTimeout = timeout; + } + @Override public void run() { boolean slept = false; while (!slept) { try { - Thread.sleep(10000); + Thread.sleep(mTimeout); slept = true; } catch (InterruptedException e) { } } synchronized (this) { if (!mWatchDogCanceled) { // Trigger watch-dog - Log.e(TAG, "Watch dog triggered"); + Log.e(TAG, "Watchdog fired: name=" + getName() + " threadId=" + + getId() + " timeout=" + mTimeout); mDeviceHost.doAbort(); } } @@ -1407,12 +1512,12 @@ public class NfcService extends Application implements DeviceHostListener { // PN544 cannot be reconfigured while EE is open return; } - WatchDogThread watchDog = new WatchDogThread(); + WatchDogThread watchDog = new WatchDogThread("applyRouting", ROUTING_WATCHDOG_MS); try { watchDog.start(); - if (PN544_QUIRK_DISCONNECT_BEFORE_RECONFIGURE && mScreenState == SCREEN_STATE_OFF) { + if (mDeviceHost.enablePN544Quirks() && mScreenState == SCREEN_STATE_OFF) { /* TODO undo this after the LLCP stack is fixed. * Use a different sequence when turning the screen off to * workaround race conditions in pn544 libnfc. The race occurs @@ -1704,6 +1809,22 @@ public class NfcService extends Application implements DeviceHostListener { break; } + case MSG_SE_LISTEN_ACTIVATED: { + if (DBG) Log.d(TAG, "SE LISTEN MODE ACTIVATED"); + Intent listenModeActivated = new Intent(); + listenModeActivated.setAction(ACTION_SE_LISTEN_ACTIVATED); + sendSeBroadcast(listenModeActivated); + break; + } + + case MSG_SE_LISTEN_DEACTIVATED: { + if (DBG) Log.d(TAG, "SE LISTEN MODE DEACTIVATED"); + Intent listenModeDeactivated = new Intent(); + listenModeDeactivated.setAction(ACTION_SE_LISTEN_DEACTIVATED); + sendSeBroadcast(listenModeDeactivated); + break; + } + default: Log.e(TAG, "Unknown message received"); break; @@ -1808,52 +1929,22 @@ public class NfcService extends Application implements DeviceHostListener { } mScreenState = params[0].intValue(); - boolean needWakelock = mScreenState == SCREEN_STATE_OFF; - if (needWakelock) { - mWakeLock.acquire(); - } - applyRouting(false); - if (needWakelock) { - mWakeLock.release(); + mRoutingWakeLock.acquire(); + try { + applyRouting(false); + } finally { + mRoutingWakeLock.release(); } return null; } } } - private final BroadcastReceiver mReceiver = new BroadcastReceiver() { + private final BroadcastReceiver mOwnerReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); - if (action.equals( - NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION)) { - // Perform applyRouting() in AsyncTask to serialize blocking calls - new ApplyRoutingTask().execute(); - } else if (action.equals(Intent.ACTION_SCREEN_ON) - || action.equals(Intent.ACTION_SCREEN_OFF) - || action.equals(Intent.ACTION_USER_PRESENT)) { - // Perform applyRouting() in AsyncTask to serialize blocking calls - int screenState = SCREEN_STATE_OFF; - if (action.equals(Intent.ACTION_SCREEN_OFF)) { - screenState = SCREEN_STATE_OFF; - } else if (action.equals(Intent.ACTION_SCREEN_ON)) { - screenState = mKeyguard.isKeyguardLocked() ? - SCREEN_STATE_ON_LOCKED : SCREEN_STATE_ON_UNLOCKED; - } else if (action.equals(Intent.ACTION_USER_PRESENT)) { - screenState = SCREEN_STATE_ON_UNLOCKED; - } - new ApplyRoutingTask().execute(Integer.valueOf(screenState)); - } else if (action.equals(ACTION_MASTER_CLEAR_NOTIFICATION)) { - EnableDisableTask eeWipeTask = new EnableDisableTask(); - eeWipeTask.execute(TASK_EE_WIPE); - try { - eeWipeTask.get(); // blocks until EE wipe is complete - } catch (ExecutionException e) { - Log.w(TAG, "failed to wipe NFC-EE"); - } catch (InterruptedException e) { - Log.w(TAG, "failed to wipe NFC-EE"); - } - } else if (action.equals(Intent.ACTION_PACKAGE_REMOVED) || + if (action.equals(Intent.ACTION_PACKAGE_REMOVED) || action.equals(Intent.ACTION_PACKAGE_ADDED) || action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE) || action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) { @@ -1877,6 +1968,42 @@ public class NfcService extends Application implements DeviceHostListener { } } } + } else if (action.equals(ACTION_MASTER_CLEAR_NOTIFICATION)) { + EnableDisableTask eeWipeTask = new EnableDisableTask(); + eeWipeTask.execute(TASK_EE_WIPE); + try { + eeWipeTask.get(); // blocks until EE wipe is complete + } catch (ExecutionException e) { + Log.w(TAG, "failed to wipe NFC-EE"); + } catch (InterruptedException e) { + Log.w(TAG, "failed to wipe NFC-EE"); + } + } + } + }; + + private final BroadcastReceiver mReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + if (action.equals( + NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION)) { + // Perform applyRouting() in AsyncTask to serialize blocking calls + new ApplyRoutingTask().execute(); + } else if (action.equals(Intent.ACTION_SCREEN_ON) + || action.equals(Intent.ACTION_SCREEN_OFF) + || action.equals(Intent.ACTION_USER_PRESENT)) { + // Perform applyRouting() in AsyncTask to serialize blocking calls + int screenState = SCREEN_STATE_OFF; + if (action.equals(Intent.ACTION_SCREEN_OFF)) { + screenState = SCREEN_STATE_OFF; + } else if (action.equals(Intent.ACTION_SCREEN_ON)) { + screenState = mKeyguard.isKeyguardLocked() ? + SCREEN_STATE_ON_LOCKED : SCREEN_STATE_ON_UNLOCKED; + } else if (action.equals(Intent.ACTION_USER_PRESENT)) { + screenState = SCREEN_STATE_ON_UNLOCKED; + } + new ApplyRoutingTask().execute(Integer.valueOf(screenState)); } else if (action.equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) { boolean isAirplaneModeOn = intent.getBooleanExtra("state", false); // Query the airplane mode from Settings.System just to make sure that diff --git a/src/com/android/nfc/P2pLinkManager.java b/src/com/android/nfc/P2pLinkManager.java index 253ddaf..9b23f65 100755 --- a/src/com/android/nfc/P2pLinkManager.java +++ b/src/com/android/nfc/P2pLinkManager.java @@ -167,6 +167,9 @@ public class P2pLinkManager implements Handler.Callback, P2pEventListener.Callba final Handler mHandler; final HandoverManager mHandoverManager; + final int mDefaultMiu; + final int mDefaultRwSize; + // Locked on NdefP2pManager.this int mLinkState; int mSendState; // valid during LINK_STATE_UP or LINK_STATE_DEBOUNCE @@ -179,9 +182,10 @@ public class P2pLinkManager implements Handler.Callback, P2pEventListener.Callba SharedPreferences mPrefs; boolean mFirstBeam; - public P2pLinkManager(Context context, HandoverManager handoverManager) { + public P2pLinkManager(Context context, HandoverManager handoverManager, int defaultMiu, + int defaultRwSize) { mNdefPushServer = new NdefPushServer(NDEFPUSH_SAP, mNppCallback); - mDefaultSnepServer = new SnepServer(mDefaultSnepCallback); + mDefaultSnepServer = new SnepServer(mDefaultSnepCallback, defaultMiu, defaultRwSize); mHandoverServer = new HandoverServer(HANDOVER_SAP, handoverManager, mHandoverCallback); if (ECHOSERVER_ENABLED) { @@ -201,6 +205,8 @@ public class P2pLinkManager implements Handler.Callback, P2pEventListener.Callba mPrefs = context.getSharedPreferences(NfcService.PREF, Context.MODE_PRIVATE); mFirstBeam = mPrefs.getBoolean(NfcService.PREF_FIRST_BEAM, true); mHandoverManager = handoverManager; + mDefaultMiu = defaultMiu; + mDefaultRwSize = defaultRwSize; } /** @@ -417,11 +423,11 @@ public class P2pLinkManager implements Handler.Callback, P2pEventListener.Callba long time = SystemClock.elapsedRealtime(); - try { if (DBG) Log.d(TAG, "Sending ndef via SNEP"); - int snepResult = doSnepProtocol(mHandoverManager, m, uris); + int snepResult = doSnepProtocol(mHandoverManager, m, uris, + mDefaultMiu, mDefaultRwSize); switch (snepResult) { case SNEP_HANDOVER_UNSUPPORTED: @@ -461,8 +467,8 @@ public class P2pLinkManager implements Handler.Callback, P2pEventListener.Callba } static int doSnepProtocol(HandoverManager handoverManager, - NdefMessage msg, Uri[] uris) throws IOException { - SnepClient snepClient = new SnepClient(); + NdefMessage msg, Uri[] uris, int miu, int rwSize) throws IOException { + SnepClient snepClient = new SnepClient(miu, rwSize); try { snepClient.connect(); } catch (IOException e) { diff --git a/src/com/android/nfc/RegisteredComponentCache.java b/src/com/android/nfc/RegisteredComponentCache.java index 1bac283..5da2cd4 100644 --- a/src/com/android/nfc/RegisteredComponentCache.java +++ b/src/com/android/nfc/RegisteredComponentCache.java @@ -19,6 +19,7 @@ package com.android.nfc; import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; +import android.app.ActivityManager; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; @@ -29,6 +30,7 @@ import android.content.pm.ResolveInfo; import android.content.pm.PackageManager.NameNotFoundException; import android.content.res.Resources; import android.content.res.XmlResourceParser; +import android.os.UserHandle; import android.util.Log; import java.io.IOException; @@ -69,12 +71,16 @@ public class RegisteredComponentCache { intentFilter.addAction(Intent.ACTION_PACKAGE_CHANGED); intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED); intentFilter.addDataScheme("package"); - mContext.registerReceiver(receiver, intentFilter); + mContext.registerReceiverAsUser(receiver, UserHandle.ALL, intentFilter, null, null); // Register for events related to sdcard installation. IntentFilter sdFilter = new IntentFilter(); sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE); sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); - mContext.registerReceiver(receiver, sdFilter); + mContext.registerReceiverAsUser(receiver, UserHandle.ALL, sdFilter, null, null); + // Generate a new list upon switching users as well + IntentFilter userFilter = new IntentFilter(); + userFilter.addAction(Intent.ACTION_USER_SWITCHED); + mContext.registerReceiverAsUser(receiver, UserHandle.ALL, userFilter, null, null); } public static class ComponentInfo { @@ -137,13 +143,21 @@ public class RegisteredComponentCache { } void generateComponentsList() { - PackageManager pm = mContext.getPackageManager(); + PackageManager pm; + try { + UserHandle currentUser = new UserHandle(ActivityManager.getCurrentUser()); + pm = mContext.createPackageContextAsUser("android", 0, + currentUser).getPackageManager(); + } catch (NameNotFoundException e) { + Log.e(TAG, "Could not create user package context"); + return; + } ArrayList components = new ArrayList(); - List resolveInfos = pm.queryIntentActivities(new Intent(mAction), - PackageManager.GET_META_DATA); + List resolveInfos = pm.queryIntentActivitiesAsUser(new Intent(mAction), + PackageManager.GET_META_DATA, ActivityManager.getCurrentUser()); for (ResolveInfo resolveInfo : resolveInfos) { try { - parseComponentInfo(resolveInfo, components); + parseComponentInfo(pm, resolveInfo, components); } catch (XmlPullParserException e) { Log.w(TAG, "Unable to load component info " + resolveInfo.toString(), e); } catch (IOException e) { @@ -158,10 +172,9 @@ public class RegisteredComponentCache { } } - void parseComponentInfo(ResolveInfo info, ArrayList components) - throws XmlPullParserException, IOException { + void parseComponentInfo(PackageManager pm, ResolveInfo info, + ArrayList components) throws XmlPullParserException, IOException { ActivityInfo ai = info.activityInfo; - PackageManager pm = mContext.getPackageManager(); XmlResourceParser parser = null; try { diff --git a/src/com/android/nfc/SendUi.java b/src/com/android/nfc/SendUi.java index 23602c9..5b5c234 100644 --- a/src/com/android/nfc/SendUi.java +++ b/src/com/android/nfc/SendUi.java @@ -183,7 +183,7 @@ public class SendUi implements Animator.AnimatorListener, View.OnTouchListener, // We're only allowed to use hardware acceleration if // isHighEndGfx() returns true - otherwise, we're too limited // on resources to do it. - mHardwareAccelerated = ActivityManager.isHighEndGfx(mDisplay); + mHardwareAccelerated = ActivityManager.isHighEndGfx(); int hwAccelerationFlags = mHardwareAccelerated ? WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED : 0; @@ -194,6 +194,8 @@ public class SendUi implements Animator.AnimatorListener, View.OnTouchListener, | hwAccelerationFlags | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN, PixelFormat.OPAQUE); + mWindowLayoutParams.privateFlags |= + WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS; mWindowLayoutParams.token = new Binder(); mFrameCounterAnimator = new TimeAnimator(); @@ -443,6 +445,9 @@ public class SendUi implements Animator.AnimatorListener, View.OnTouchListener, // Navbar has different sizes, depending on orientation final int navBarHeight = hasNavBar ? mContext.getResources().getDimensionPixelSize( com.android.internal.R.dimen.navigation_bar_height) : 0; + final int navBarHeightLandscape = hasNavBar ? mContext.getResources().getDimensionPixelSize( + com.android.internal.R.dimen.navigation_bar_height_landscape) : 0; + final int navBarWidth = hasNavBar ? mContext.getResources().getDimensionPixelSize( com.android.internal.R.dimen.navigation_bar_width) : 0; @@ -483,13 +488,20 @@ public class SendUi implements Animator.AnimatorListener, View.OnTouchListener, int newTop = statusBarHeight; int newWidth = bitmap.getWidth(); int newHeight = bitmap.getHeight(); + float smallestWidth = (float)Math.min(newWidth, newHeight); + float smallestWidthDp = smallestWidth / (mDisplayMetrics.densityDpi / 160f); if (bitmap.getWidth() < bitmap.getHeight()) { // Portrait mode: status bar is at the top, navbar bottom, width unchanged newHeight = bitmap.getHeight() - statusBarHeight - navBarHeight; } else { - // Landscape mode: status bar is at the top, navbar right - newHeight = bitmap.getHeight() - statusBarHeight; - newWidth = bitmap.getWidth() - navBarWidth; + // Landscape mode: status bar is at the top + // Navbar: bottom on >599dp width devices, otherwise to the side + if (smallestWidthDp > 599) { + newHeight = bitmap.getHeight() - statusBarHeight - navBarHeightLandscape; + } else { + newHeight = bitmap.getHeight() - statusBarHeight; + newWidth = bitmap.getWidth() - navBarWidth; + } } bitmap = Bitmap.createBitmap(bitmap, newLeft, newTop, newWidth, newHeight); diff --git a/src/com/android/nfc/handover/BluetoothHeadsetHandover.java b/src/com/android/nfc/handover/BluetoothHeadsetHandover.java index 7974dfa..1377160 100644 --- a/src/com/android/nfc/handover/BluetoothHeadsetHandover.java +++ b/src/com/android/nfc/handover/BluetoothHeadsetHandover.java @@ -16,6 +16,7 @@ package com.android.nfc.handover; +import android.app.ActivityManager; import android.bluetooth.BluetoothA2dp; import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; @@ -28,6 +29,7 @@ import android.content.IntentFilter; import android.os.Handler; import android.os.Looper; import android.os.Message; +import android.os.UserHandle; import android.util.Log; import android.view.KeyEvent; import android.widget.Toast; @@ -44,9 +46,8 @@ import com.android.nfc.R; * designed to be re-used after the sequence has completed or timed out. * Subsequent NFC interactions should use new objects. * - * TODO: UI review */ -public class BluetoothHeadsetHandover { +public class BluetoothHeadsetHandover implements BluetoothProfile.ServiceListener { static final String TAG = HandoverManager.TAG; static final boolean DBG = HandoverManager.DBG; @@ -57,28 +58,33 @@ public class BluetoothHeadsetHandover { static final int STATE_INIT = 0; static final int STATE_TURNING_ON = 1; - static final int STATE_WAITING_FOR_BOND_CONFIRMATION = 2; - static final int STATE_BONDING = 3; - static final int STATE_CONNECTING = 4; - static final int STATE_DISCONNECTING = 5; - static final int STATE_COMPLETE = 6; + static final int STATE_WAITING_FOR_PROXIES = 2; + static final int STATE_INIT_COMPLETE = 3; + static final int STATE_WAITING_FOR_BOND_CONFIRMATION = 4; + static final int STATE_BONDING = 5; + static final int STATE_CONNECTING = 6; + static final int STATE_DISCONNECTING = 7; + static final int STATE_COMPLETE = 8; static final int RESULT_PENDING = 0; static final int RESULT_CONNECTED = 1; static final int RESULT_DISCONNECTED = 2; + static final int ACTION_INIT = 0; static final int ACTION_DISCONNECT = 1; static final int ACTION_CONNECT = 2; static final int MSG_TIMEOUT = 1; + static final int MSG_NEXT_STEP = 2; final Context mContext; final BluetoothDevice mDevice; final String mName; final HandoverPowerManager mHandoverPowerManager; - final BluetoothA2dp mA2dp; - final BluetoothHeadset mHeadset; final Callback mCallback; + final BluetoothAdapter mBluetoothAdapter; + + final Object mLock = new Object(); // only used on main thread int mAction; @@ -86,21 +92,24 @@ public class BluetoothHeadsetHandover { int mHfpResult; // used only in STATE_CONNECTING and STATE_DISCONNETING int mA2dpResult; // used only in STATE_CONNECTING and STATE_DISCONNETING + // protected by mLock + BluetoothA2dp mA2dp; + BluetoothHeadset mHeadset; + public interface Callback { public void onBluetoothHeadsetHandoverComplete(boolean connected); } public BluetoothHeadsetHandover(Context context, BluetoothDevice device, String name, - HandoverPowerManager powerManager, BluetoothA2dp a2dp, BluetoothHeadset headset, - Callback callback) { + HandoverPowerManager powerManager, Callback callback) { checkMainThread(); // mHandler must get get constructed on Main Thread for toasts to work mContext = context; mDevice = device; mName = name; mHandoverPowerManager = powerManager; - mA2dp = a2dp; - mHeadset = headset; mCallback = callback; + mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); + mState = STATE_INIT; } @@ -111,6 +120,7 @@ public class BluetoothHeadsetHandover { public void start() { checkMainThread(); if (mState != STATE_INIT) return; + if (mBluetoothAdapter == null) return; IntentFilter filter = new IntentFilter(); filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED); @@ -122,15 +132,8 @@ public class BluetoothHeadsetHandover { mContext.registerReceiver(mReceiver, filter); - if (mA2dp.getConnectedDevices().contains(mDevice) || - mHeadset.getConnectedDevices().contains(mDevice)) { - Log.i(TAG, "ACTION_DISCONNECT addr=" + mDevice + " name=" + mName); - mAction = ACTION_DISCONNECT; - } else { - Log.i(TAG, "ACTION_CONNECT addr=" + mDevice + " name=" + mName); - mAction = ACTION_CONNECT; - } mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_TIMEOUT), TIMEOUT_MS); + mAction = ACTION_INIT; nextStep(); } @@ -138,35 +141,83 @@ public class BluetoothHeadsetHandover { * Called to execute next step in state machine */ void nextStep() { - if (mAction == ACTION_CONNECT) { + if (mAction == ACTION_INIT) { + nextStepInit(); + } else if (mAction == ACTION_CONNECT) { nextStepConnect(); } else { nextStepDisconnect(); } } - void nextStepDisconnect() { + /* + * Enables bluetooth and gets the profile proxies + */ + void nextStepInit() { switch (mState) { case STATE_INIT: - mState = STATE_DISCONNECTING; - if (mHeadset.getConnectionState(mDevice) != BluetoothProfile.STATE_DISCONNECTED) { - mHfpResult = RESULT_PENDING; - mHeadset.disconnect(mDevice); - } else { - mHfpResult = RESULT_DISCONNECTED; - } - if (mA2dp.getConnectionState(mDevice) != BluetoothProfile.STATE_DISCONNECTED) { - mA2dpResult = RESULT_PENDING; - mA2dp.disconnect(mDevice); - } else { - mA2dpResult = RESULT_DISCONNECTED; + if (!mHandoverPowerManager.isBluetoothEnabled()) { + if (mHandoverPowerManager.enableBluetooth()) { + // Bluetooth is being enabled + mState = STATE_TURNING_ON; + } else { + toast(mContext.getString(R.string.failed_to_enable_bt)); + complete(false); + } + break; } - if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { - toast(mContext.getString(R.string.disconnecting_headset ) + " " + - mName + "..."); + // fall-through + case STATE_TURNING_ON: + if (mA2dp == null || mHeadset == null) { + mState = STATE_WAITING_FOR_PROXIES; + if (!getProfileProxys()) { + complete(false); + } break; } // fall-through + case STATE_WAITING_FOR_PROXIES: + mState = STATE_INIT_COMPLETE; + // Check connected devices and see if we need to disconnect + synchronized(mLock) { + if (mA2dp.getConnectedDevices().contains(mDevice) || + mHeadset.getConnectedDevices().contains(mDevice)) { + Log.i(TAG, "ACTION_DISCONNECT addr=" + mDevice + " name=" + mName); + mAction = ACTION_DISCONNECT; + } else { + Log.i(TAG, "ACTION_CONNECT addr=" + mDevice + " name=" + mName); + mAction = ACTION_CONNECT; + } + } + nextStep(); + } + + } + + void nextStepDisconnect() { + switch (mState) { + case STATE_INIT_COMPLETE: + mState = STATE_DISCONNECTING; + synchronized (mLock) { + if (mHeadset.getConnectionState(mDevice) != BluetoothProfile.STATE_DISCONNECTED) { + mHfpResult = RESULT_PENDING; + mHeadset.disconnect(mDevice); + } else { + mHfpResult = RESULT_DISCONNECTED; + } + if (mA2dp.getConnectionState(mDevice) != BluetoothProfile.STATE_DISCONNECTED) { + mA2dpResult = RESULT_PENDING; + mA2dp.disconnect(mDevice); + } else { + mA2dpResult = RESULT_DISCONNECTED; + } + if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { + toast(mContext.getString(R.string.disconnecting_headset ) + " " + + mName + "..."); + break; + } + } + // fall-through case STATE_DISCONNECTING: if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { // still disconnecting @@ -178,26 +229,26 @@ public class BluetoothHeadsetHandover { complete(false); break; } + + } + + boolean getProfileProxys() { + if(!mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.HEADSET)) + return false; + + if(!mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.A2DP)) + return false; + + return true; } void nextStepConnect() { switch (mState) { - case STATE_INIT: - if (!mHandoverPowerManager.isBluetoothEnabled()) { - if (mHandoverPowerManager.enableBluetooth()) { - // Bluetooth is being enabled - mState = STATE_TURNING_ON; - } else { - toast(mContext.getString(R.string.failed_to_enable_bt)); - complete(false); - } - break; - } - // fall-through - case STATE_TURNING_ON: + case STATE_INIT_COMPLETE: if (mDevice.getBondState() != BluetoothDevice.BOND_BONDED) { requestPairConfirmation(); mState = STATE_WAITING_FOR_BOND_CONFIRMATION; + break; } // fall-through @@ -211,21 +262,23 @@ public class BluetoothHeadsetHandover { // Bluetooth Profile service will correctly serialize // HFP then A2DP connect mState = STATE_CONNECTING; - if (mHeadset.getConnectionState(mDevice) != BluetoothProfile.STATE_CONNECTED) { - mHfpResult = RESULT_PENDING; - mHeadset.connect(mDevice); - } else { - mHfpResult = RESULT_CONNECTED; - } - if (mA2dp.getConnectionState(mDevice) != BluetoothProfile.STATE_CONNECTED) { - mA2dpResult = RESULT_PENDING; - mA2dp.connect(mDevice); - } else { - mA2dpResult = RESULT_CONNECTED; - } - if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { - toast(mContext.getString(R.string.connecting_headset) + " " + mName + "..."); - break; + synchronized (mLock) { + if (mHeadset.getConnectionState(mDevice) != BluetoothProfile.STATE_CONNECTED) { + mHfpResult = RESULT_PENDING; + mHeadset.connect(mDevice); + } else { + mHfpResult = RESULT_CONNECTED; + } + if (mA2dp.getConnectionState(mDevice) != BluetoothProfile.STATE_CONNECTED) { + mA2dpResult = RESULT_PENDING; + mA2dp.connect(mDevice); + } else { + mA2dpResult = RESULT_CONNECTED; + } + if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { + toast(mContext.getString(R.string.connecting_headset) + " " + mName + "..."); + break; + } } // fall-through case STATE_CONNECTING: @@ -260,7 +313,7 @@ public class BluetoothHeadsetHandover { if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action) && mState == STATE_TURNING_ON) { int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR); if (state == BluetoothAdapter.STATE_ON) { - nextStepConnect(); + nextStep(); } else if (state == BluetoothAdapter.STATE_OFF) { toast(mContext.getString(R.string.failed_to_enable_bt)); complete(false); @@ -313,6 +366,16 @@ public class BluetoothHeadsetHandover { mState = STATE_COMPLETE; mContext.unregisterReceiver(mReceiver); mHandler.removeMessages(MSG_TIMEOUT); + synchronized (mLock) { + if (mA2dp != null) { + mBluetoothAdapter.closeProfileProxy(BluetoothProfile.A2DP, mA2dp); + } + if (mHeadset != null) { + mBluetoothAdapter.closeProfileProxy(BluetoothProfile.HEADSET, mHeadset); + } + mA2dp = null; + mHeadset = null; + } mCallback.onBluetoothHeadsetHandoverComplete(connected); } @@ -324,10 +387,10 @@ public class BluetoothHeadsetHandover { Intent intent = new Intent(Intent.ACTION_MEDIA_BUTTON); intent.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MEDIA_PLAY)); - mContext.sendOrderedBroadcast(intent, null); + mContext.sendOrderedBroadcastAsUser(intent, UserHandle.CURRENT, null, null, null, 0, null, null); intent.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_PLAY)); - mContext.sendOrderedBroadcast(intent, null); + mContext.sendOrderedBroadcastAsUser(intent, UserHandle.CURRENT, null, null, null, 0, null, null); } void requestPairConfirmation() { @@ -336,7 +399,7 @@ public class BluetoothHeadsetHandover { dialogIntent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice); - mContext.startActivity(dialogIntent); + mContext.startActivityAsUser(dialogIntent, new UserHandle(UserHandle.USER_CURRENT)); } final Handler mHandler = new Handler() { @@ -348,6 +411,9 @@ public class BluetoothHeadsetHandover { Log.i(TAG, "Timeout completing BT handover"); complete(false); break; + case MSG_NEXT_STEP: + nextStep(); + break; } } }; @@ -364,4 +430,29 @@ public class BluetoothHeadsetHandover { throw new IllegalThreadStateException("must be called on main thread"); } } + + @Override + public void onServiceConnected(int profile, BluetoothProfile proxy) { + synchronized (mLock) { + switch (profile) { + case BluetoothProfile.HEADSET: + mHeadset = (BluetoothHeadset) proxy; + if (mA2dp != null) { + mHandler.sendEmptyMessage(MSG_NEXT_STEP); + } + break; + case BluetoothProfile.A2DP: + mA2dp = (BluetoothA2dp) proxy; + if (mHeadset != null) { + mHandler.sendEmptyMessage(MSG_NEXT_STEP); + } + break; + } + } + } + + @Override + public void onServiceDisconnected(int profile) { + // We can ignore these + } } diff --git a/src/com/android/nfc/handover/HandoverManager.java b/src/com/android/nfc/handover/HandoverManager.java index f77f780..e7e807d 100644 --- a/src/com/android/nfc/handover/HandoverManager.java +++ b/src/com/android/nfc/handover/HandoverManager.java @@ -33,11 +33,8 @@ import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; import android.app.Notification.Builder; -import android.bluetooth.BluetoothA2dp; import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; -import android.bluetooth.BluetoothHeadset; -import android.bluetooth.BluetoothProfile; import android.content.BroadcastReceiver; import android.content.ContentResolver; import android.content.Context; @@ -52,6 +49,7 @@ import android.os.Environment; import android.os.Handler; import android.os.Message; import android.os.SystemClock; +import android.os.UserHandle; import android.util.Log; import android.util.Pair; @@ -62,8 +60,7 @@ import com.android.nfc.R; /** * Manages handover of NFC to other technologies. */ -public class HandoverManager implements BluetoothProfile.ServiceListener, - BluetoothHeadsetHandover.Callback { +public class HandoverManager implements BluetoothHeadsetHandover.Callback { static final String TAG = "NfcHandover"; static final boolean DBG = true; @@ -142,8 +139,6 @@ public class HandoverManager implements BluetoothProfile.ServiceListener, // Variables below synchronized on HandoverManager.this final HashMap, HandoverTransfer> mTransfers; - BluetoothHeadset mBluetoothHeadset; - BluetoothA2dp mBluetoothA2dp; BluetoothHeadsetHandover mBluetoothHeadsetHandover; boolean mBluetoothHeadsetConnected; @@ -390,7 +385,8 @@ public class HandoverManager implements BluetoothProfile.ServiceListener, notBuilder.setContentText(mContext.getString(R.string.beam_touch_to_view)); Intent viewIntent = buildViewIntent(); - PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, viewIntent, 0); + PendingIntent contentIntent = PendingIntent.getActivityAsUser( + mContext, 0, viewIntent, 0, null, UserHandle.CURRENT); notBuilder.setContentIntent(contentIntent); @@ -410,7 +406,8 @@ public class HandoverManager implements BluetoothProfile.ServiceListener, return; } - mNotificationManager.notify(mNotificationId, notBuilder.build()); + mNotificationManager.notifyAsUser(null, mNotificationId, notBuilder.build(), + UserHandle.CURRENT); } synchronized void updateStateAndNotification(int newState) { @@ -537,7 +534,7 @@ public class HandoverManager implements BluetoothProfile.ServiceListener, Uri uri = mediaUri != null ? mediaUri : Uri.parse(ContentResolver.SCHEME_FILE + "://" + filePath); viewIntent.setDataAndTypeAndNormalize(uri, mimeTypes.get(filePath)); - + viewIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); return viewIntent; } @@ -612,10 +609,6 @@ public class HandoverManager implements BluetoothProfile.ServiceListener, public HandoverManager(Context context) { mContext = context; mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); - if (mBluetoothAdapter != null) { - mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.HEADSET); - mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.A2DP); - } mNotificationManager = (NotificationManager) mContext.getSystemService( Context.NOTIFICATION_SERVICE); @@ -792,9 +785,7 @@ public class HandoverManager implements BluetoothProfile.ServiceListener, if (!handover.valid) return true; synchronized (HandoverManager.this) { - if (mBluetoothAdapter == null || - mBluetoothA2dp == null || - mBluetoothHeadset == null) { + if (mBluetoothAdapter == null) { if (DBG) Log.d(TAG, "BT handover, but BT not available"); return true; } @@ -803,7 +794,7 @@ public class HandoverManager implements BluetoothProfile.ServiceListener, return true; } mBluetoothHeadsetHandover = new BluetoothHeadsetHandover(mContext, handover.device, - handover.name, mHandoverPowerManager, mBluetoothA2dp, mBluetoothHeadset, this); + handover.name, mHandoverPowerManager, this); mBluetoothHeadsetHandover.start(); } return true; @@ -983,34 +974,6 @@ public class HandoverManager implements BluetoothProfile.ServiceListener, } @Override - public void onServiceConnected(int profile, BluetoothProfile proxy) { - synchronized (HandoverManager.this) { - switch (profile) { - case BluetoothProfile.HEADSET: - mBluetoothHeadset = (BluetoothHeadset) proxy; - break; - case BluetoothProfile.A2DP: - mBluetoothA2dp = (BluetoothA2dp) proxy; - break; - } - } - } - - @Override - public void onServiceDisconnected(int profile) { - synchronized (HandoverManager.this) { - switch (profile) { - case BluetoothProfile.HEADSET: - mBluetoothHeadset = null; - break; - case BluetoothProfile.A2DP: - mBluetoothA2dp = null; - break; - } - } - } - - @Override public void onBluetoothHeadsetHandoverComplete(boolean connected) { synchronized (HandoverManager.this) { mBluetoothHeadsetHandover = null; diff --git a/src/com/android/nfc/ndefpush/NdefPushServer.java b/src/com/android/nfc/ndefpush/NdefPushServer.java index ca58a67..bf92c17 100755 --- a/src/com/android/nfc/ndefpush/NdefPushServer.java +++ b/src/com/android/nfc/ndefpush/NdefPushServer.java @@ -117,28 +117,49 @@ public class NdefPushServer { /** Server class, used to listen for incoming connection request */ class ServerThread extends Thread { + // Variables below synchronized on NdefPushServer.this boolean mRunning = true; LlcpServerSocket mServerSocket; @Override public void run() { - while (mRunning) { + boolean threadRunning; + synchronized (NdefPushServer.this) { + threadRunning = mRunning; + } + while (threadRunning) { if (DBG) Log.d(TAG, "about create LLCP service socket"); try { - mServerSocket = mService.createLlcpServerSocket(mSap, SERVICE_NAME, - MIU, 1, 1024); + synchronized (NdefPushServer.this) { + mServerSocket = mService.createLlcpServerSocket(mSap, SERVICE_NAME, + MIU, 1, 1024); + } if (mServerSocket == null) { if (DBG) Log.d(TAG, "failed to create LLCP service socket"); return; } if (DBG) Log.d(TAG, "created LLCP service socket"); - while (mRunning) { + synchronized (NdefPushServer.this) { + threadRunning = mRunning; + } + + while (threadRunning) { + LlcpServerSocket serverSocket; + synchronized (NdefPushServer.this) { + serverSocket = mServerSocket; + } + if (serverSocket == null) return; + if (DBG) Log.d(TAG, "about to accept"); - LlcpSocket communicationSocket = mServerSocket.accept(); + LlcpSocket communicationSocket = serverSocket.accept(); if (DBG) Log.d(TAG, "accept returned " + communicationSocket); if (communicationSocket != null) { new ConnectionThread(communicationSocket).start(); } + + synchronized (NdefPushServer.this) { + threadRunning = mRunning; + } } if (DBG) Log.d(TAG, "stop running"); } catch (LlcpException e) { @@ -146,28 +167,36 @@ public class NdefPushServer { } catch (IOException e) { Log.e(TAG, "IO error", e); } finally { - if (mServerSocket != null) { - if (DBG) Log.d(TAG, "about to close"); - try { - mServerSocket.close(); - } catch (IOException e) { - // ignore + synchronized (NdefPushServer.this) { + if (mServerSocket != null) { + if (DBG) Log.d(TAG, "about to close"); + try { + mServerSocket.close(); + } catch (IOException e) { + // ignore + } + mServerSocket = null; } - mServerSocket = null; } } + + synchronized (NdefPushServer.this) { + threadRunning = mRunning; + } } } public void shutdown() { - mRunning = false; - if (mServerSocket != null) { - try { - mServerSocket.close(); - } catch (IOException e) { - // ignore + synchronized (NdefPushServer.this) { + mRunning = false; + if (mServerSocket != null) { + try { + mServerSocket.close(); + } catch (IOException e) { + // ignore + } + mServerSocket = null; } - mServerSocket = null; } } } diff --git a/src/com/android/nfc/snep/SnepClient.java b/src/com/android/nfc/snep/SnepClient.java index 8dca6ae..fae8143 100644 --- a/src/com/android/nfc/snep/SnepClient.java +++ b/src/com/android/nfc/snep/SnepClient.java @@ -29,7 +29,8 @@ public final class SnepClient { private static final String TAG = "SnepClient"; private static final boolean DBG = false; private static final int DEFAULT_ACCEPTABLE_LENGTH = 100*1024; - private static final int MIU = 128; + private static final int DEFAULT_MIU = 128; + private static final int DEFAULT_RWSIZE = 1; SnepMessenger mMessenger = null; private final Object mTransmissionLock = new Object(); @@ -38,6 +39,8 @@ public final class SnepClient { private int mState = DISCONNECTED; private final int mAcceptableLength; private final int mFragmentLength; + private final int mMiu; + private final int mRwSize; private static final int DISCONNECTED = 0; private static final int CONNECTING = 1; @@ -48,6 +51,8 @@ public final class SnepClient { mPort = SnepServer.DEFAULT_PORT; mAcceptableLength = DEFAULT_ACCEPTABLE_LENGTH; mFragmentLength = -1; + mMiu = DEFAULT_MIU; + mRwSize = DEFAULT_RWSIZE; } public SnepClient(String serviceName) { @@ -55,6 +60,17 @@ public final class SnepClient { mPort = -1; mAcceptableLength = DEFAULT_ACCEPTABLE_LENGTH; mFragmentLength = -1; + mMiu = DEFAULT_MIU; + mRwSize = DEFAULT_RWSIZE; + } + + public SnepClient(int miu, int rwSize) { + mServiceName = SnepServer.DEFAULT_SERVICE_NAME; + mPort = SnepServer.DEFAULT_PORT; + mAcceptableLength = DEFAULT_ACCEPTABLE_LENGTH; + mFragmentLength = -1; + mMiu = miu; + mRwSize = rwSize; } SnepClient(String serviceName, int fragmentLength) { @@ -62,6 +78,8 @@ public final class SnepClient { mPort = -1; mAcceptableLength = DEFAULT_ACCEPTABLE_LENGTH; mFragmentLength = fragmentLength; + mMiu = DEFAULT_MIU; + mRwSize = DEFAULT_RWSIZE; } SnepClient(String serviceName, int acceptableLength, int fragmentLength) { @@ -69,6 +87,8 @@ public final class SnepClient { mPort = -1; mAcceptableLength = acceptableLength; mFragmentLength = fragmentLength; + mMiu = DEFAULT_MIU; + mRwSize = DEFAULT_RWSIZE; } public void put(NdefMessage msg) throws IOException { @@ -122,7 +142,7 @@ public final class SnepClient { try { if (DBG) Log.d(TAG, "about to create socket"); // Connect to the snep server on the remote side - socket = NfcService.getInstance().createLlcpSocket(0, MIU, 1, 1024); + socket = NfcService.getInstance().createLlcpSocket(0, mMiu, mRwSize, 1024); if (socket == null) { throw new IOException("Could not connect to socket."); } diff --git a/src/com/android/nfc/snep/SnepServer.java b/src/com/android/nfc/snep/SnepServer.java index 84bb673..aa7da48 100644 --- a/src/com/android/nfc/snep/SnepServer.java +++ b/src/com/android/nfc/snep/SnepServer.java @@ -34,9 +34,10 @@ import java.io.IOException; public final class SnepServer { private static final String TAG = "SnepServer"; private static final boolean DBG = false; + private static final int DEFAULT_MIU = 248; + private static final int DEFAULT_RW_SIZE = 1; public static final int DEFAULT_PORT = 4; - private static final int MIU = 248; public static final String DEFAULT_SERVICE_NAME = "urn:nfc:sn:snep"; @@ -44,6 +45,8 @@ public final class SnepServer { final String mServiceName; final int mServiceSap; final int mFragmentLength; + final int mMiu; + final int mRwSize; /** Protected by 'this', null when stopped, non-null when running */ ServerThread mServerThread = null; @@ -59,6 +62,8 @@ public final class SnepServer { mServiceName = DEFAULT_SERVICE_NAME; mServiceSap = DEFAULT_PORT; mFragmentLength = -1; + mMiu = DEFAULT_MIU; + mRwSize = DEFAULT_RW_SIZE; } public SnepServer(String serviceName, int serviceSap, Callback callback) { @@ -66,6 +71,17 @@ public final class SnepServer { mServiceName = serviceName; mServiceSap = serviceSap; mFragmentLength = -1; + mMiu = DEFAULT_MIU; + mRwSize = DEFAULT_RW_SIZE; + } + + public SnepServer(Callback callback, int miu, int rwSize) { + mCallback = callback; + mServiceName = DEFAULT_SERVICE_NAME; + mServiceSap = DEFAULT_PORT; + mFragmentLength = -1; + mMiu = miu; + mRwSize = rwSize; } SnepServer(String serviceName, int serviceSap, int fragmentLength, Callback callback) { @@ -73,6 +89,8 @@ public final class SnepServer { mServiceName = serviceName; mServiceSap = serviceSap; mFragmentLength = fragmentLength; + mMiu = DEFAULT_MIU; + mRwSize = DEFAULT_RW_SIZE; } /** Connection class, used to handle incoming connections */ @@ -168,7 +186,7 @@ public final class SnepServer { try { synchronized (SnepServer.this) { mServerSocket = NfcService.getInstance().createLlcpServerSocket(mServiceSap, - mServiceName, MIU, 1, 1024); + mServiceName, mMiu, mRwSize, 1024); } if (mServerSocket == null) { if (DBG) Log.d(TAG, "failed to create LLCP service socket"); -- cgit v1.1