/*
* 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"
#include <ScopedLocalRef.h>
/* Some older PN544-based solutions would only send the first SYMM back
* (as an initiator) after the full LTO (750ms). But our connect timer
* starts immediately, and hence we may timeout if the timer is set to
* 1000 ms. Worse, this causes us to immediately connect to the NPP
* socket, causing concurrency issues in that stack. Increase the default
* timeout to 2000 ms, giving us enough time to complete the first connect.
*/
#define LLCP_DATA_LINK_TIMEOUT 2000
using namespace android;
namespace android
{
extern void nativeNfcTag_registerNdefTypeHandler ();
extern void nativeNfcTag_deregisterNdefTypeHandler ();
extern void startRfDiscovery (bool isStart);
extern bool isDiscoveryStarted ();
}
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)
{
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<P2pServer> 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<P2pServer> 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<P2pServer> 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);
sp<P2pServer> pSrv = NULL;
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);
//no longer need to receive NDEF message from a tag
android::nativeNfcTag_deregisterNdefTypeHandler ();
mRemoteWKS = activated.remote_wks;
JNIEnv* e = NULL;
ScopedAttach attach(nat->vm, &e);
if (e == NULL)
{
ALOGE ("%s: jni env is null", fn);
return;
}
ALOGD ("%s: get object class", fn);
ScopedLocalRef<jclass> tag_cls(e, e->GetObjectClass(nat->cached_P2pDevice));
if (e->ExceptionCheck()) {
e->ExceptionClear();
ALOGE ("%s: fail get p2p device", fn);
return;
}
ALOGD ("%s: instantiate", fn);
/* New target instance */
jmethodID ctor = e->GetMethodID(tag_cls.get(), "<init>", "()V");
ScopedLocalRef<jobject> tag(e, e->NewObject(tag_cls.get(), ctor));
/* Set P2P Target mode */
jfieldID f = e->GetFieldID(tag_cls.get(), "mMode", "I");
if (activated.is_initiator == TRUE) {
ALOGD ("%s: p2p initiator", fn);
e->SetIntField(tag.get(), f, (jint) MODE_P2P_INITIATOR);
} else {
ALOGD ("%s: p2p target", fn);
e->SetIntField(tag.get(), f, (jint) MODE_P2P_TARGET);
}
/* Set LLCP version */
f = e->GetFieldID(tag_cls.get(), "mLlcpVersion", "B");
e->SetByteField(tag.get(), f, (jbyte) activated.remote_version);
/* Set tag handle */
f = e->GetFieldID(tag_cls.get(), "mHandle", "I");
e->SetIntField(tag.get(), f, (jint) 0x1234); // ?? This handle is not used for anything
if (nat->tag != NULL) {
e->DeleteGlobalRef(nat->tag);
}
nat->tag = e->NewGlobalRef(tag.get());
ALOGD ("%s: notify nfc service", fn);
/* Notify manager that new a P2P device was found */
e->CallVoidMethod(nat->manager, android::gCachedNfcManagerNotifyLlcpLinkActivation, tag.get());
if (e->ExceptionCheck()) {
e->ExceptionClear();
ALOGE ("%s: fail notify", fn);
}
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;
ScopedAttach attach(nat->vm, &e);
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);
}
//let the tag-reading code handle NDEF data event
android::nativeNfcTag_registerNdefTypeHandler ();
ALOGD ("%s: exit", fn);
}
void PeerToPeer::llcpFirstPacketHandler (nfc_jni_native_data* nat)
{
static const char fn [] = "PeerToPeer::llcpFirstPacketHandler";
ALOGD ("%s: enter", fn);
JNIEnv* e = NULL;
ScopedAttach attach(nat->vm, &e);
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::gCachedNfcManagerNotifyLlcpFirstPacketReceived, nat->tag);
if (e->ExceptionCheck())
{
e->ExceptionClear();
ALOGE ("%s: fail notify", fn);
}
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";
sp<P2pServer> 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<P2pServer> pSrv = NULL;
bool isPollingTempStopped = false;
mMutex.lock();
if ((pSrv = findServerLocked (jniHandle)) == NULL)
{
ALOGE ("%s: unknown service handle: %u", fn, jniHandle);
mMutex.unlock();
return (false);
}
mMutex.unlock();
if (isDiscoveryStarted ())
{
isPollingTempStopped = true;
startRfDiscovery (false);
}
{
// 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);
if (isPollingTempStopped)
{
startRfDiscovery (true);
}
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<P2pClient> 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";
AutoMutex mutex(mMutex);
// If the connection is a for a client, delete the client itself
for (int 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 (int 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: Establish 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: Establish 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: 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 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<P2pClient> 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<char*>(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<P2pClient> 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<P2pClient> 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<P2pClient> 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<NfaConn> PeerToPeer::findConnection (tNFA_HANDLE nfaConnHandle)
{
AutoMutex mutex(mMutex);
// First, look through all the client control blocks
for (int 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 (int ii = 0; ii < sMax; ii++)
{
if (mServers[ii] != NULL)
{
sp<NfaConn> 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<NfaConn> PeerToPeer::findConnection (tJNI_HANDLE jniHandle)
{
AutoMutex mutex(mMutex);
// First, look through all the client control blocks
for (int 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 (int ii = 0; ii < sMax; ii++)
{
if (mServers[ii] != NULL)
{
sp<NfaConn> 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<NfaConn> 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<NfaConn> 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<P2pClient> pClient = NULL;
sp<NfaConn> 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<NfaConn> 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<NfaConn> 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: getP2pListenMask
**
** Description: Get the set of technologies that P2P is listening.
**
** Returns: Set of technologies.
**
*******************************************************************************/
tNFA_TECHNOLOGY_MASK PeerToPeer::getP2pListenMask ()
{
return mP2pListenTechMask;
}
/*******************************************************************************
**
** Function: resetP2pListenMask
**
** Description: Reset the p2p listen technology mask to initial value.
**
** Returns: None.
**
*******************************************************************************/
void PeerToPeer::resetP2pListenMask ()
{
unsigned long num = 0;
mP2pListenTechMask = NFA_TECHNOLOGY_MASK_A
| NFA_TECHNOLOGY_MASK_F
| NFA_TECHNOLOGY_MASK_A_ACTIVE
| NFA_TECHNOLOGY_MASK_F_ACTIVE;
if (GetNumValue ("P2P_LISTEN_TECH_MASK", &num, sizeof (num)))
mP2pListenTechMask = num;
}
/*******************************************************************************
**
** 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);
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
{
// Disconnect through all the clients
for (int 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 (int 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<P2pServer> pSrv = NULL;
sp<NfaConn> 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<NfaConn> pConn = NULL;
sp<P2pClient> 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.findClient (eventData->disc.handle)) == NULL)
{
ALOGE ("%s: NFA_P2P_DISC_EVT: can't find client 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_TIMEOUT,
LLCP_DELAY_TIME_TO_SEND_FIRST_PDU);
if (stat != NFA_STATUS_OK)
ALOGE ("%s: fail set LLCP config; error=0x%X", fn, stat);
if (sSnepServiceName.compare(mServiceName) == 0)
serverSap = LLCP_SAP_SNEP; //LLCP_SAP_SNEP == 4
{
SyncEventGuard guard (mRegServerEvent);
stat = NFA_P2pRegisterServer (serverSap, NFA_P2P_DLINK_TYPE, const_cast<char*>(mServiceName.c_str()),
PeerToPeer::nfaServerCallback);
if (stat != NFA_STATUS_OK)
{
ALOGE ("%s: fail register p2p server; error=0x%X", fn, stat);
return (false);
}
ALOGD ("%s: wait for listen-completion event", fn);
// Wait for NFA_P2P_REG_SERVER_EVT
mRegServerEvent.wait ();
}
return (mNfaP2pServerHandle != NFA_HANDLE_INVALID);
}
bool P2pServer::accept(PeerToPeer::tJNI_HANDLE serverJniHandle, PeerToPeer::tJNI_HANDLE connJniHandle,
int maxInfoUnit, int recvWindow)
{
static const char fn [] = "P2pServer::accept";
tNFA_STATUS nfaStat = NFA_STATUS_OK;
sp<NfaConn> connection = allocateConnection(connJniHandle);
if (connection == NULL) {
ALOGE ("%s: failed to allocate new server connection", fn);
return false;
}
{
// Wait for NFA_P2P_CONN_REQ_EVT or NFA_NDEF_DATA_EVT when remote device requests connection
SyncEventGuard guard (mConnRequestEvent);
ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; wait for incoming connection", fn,
serverJniHandle, connJniHandle);
mConnRequestEvent.wait();
ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; got incoming connection", fn,
serverJniHandle, connJniHandle, connection->mNfaConnHandle);
}
if (connection->mNfaConnHandle == NFA_HANDLE_INVALID)
{
removeServerConnection(connJniHandle);
ALOGD ("%s: no handle assigned", fn);
return (false);
}
if (maxInfoUnit > (int)LLCP_MIU)
{
ALOGD ("%s: overriding the miu passed by the app(%d) with stack miu(%zu)", fn, maxInfoUnit, LLCP_MIU);
maxInfoUnit = LLCP_MIU;
}
ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; try accept", fn,
serverJniHandle, connJniHandle, connection->mNfaConnHandle);
nfaStat = NFA_P2pAcceptConn (connection->mNfaConnHandle, maxInfoUnit, recvWindow);
if (nfaStat != NFA_STATUS_OK)
{
ALOGE ("%s: fail to accept remote; error=0x%X", fn, nfaStat);
return (false);
}
ALOGD ("%s: exit; serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X", fn,
serverJniHandle, connJniHandle, connection->mNfaConnHandle);
return (true);
}
void P2pServer::unblockAll()
{
AutoMutex mutex(mMutex);
for (int jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
{
if (mServerConn[jj] != NULL)
{
mServerConn[jj]->mNfaConnHandle = NFA_HANDLE_INVALID;
{
SyncEventGuard guard1 (mServerConn[jj]->mCongEvent);
mServerConn[jj]->mCongEvent.notifyOne (); //unblock write (if congested)
}
{
SyncEventGuard guard2 (mServerConn[jj]->mReadEvent);
mServerConn[jj]->mReadEvent.notifyOne (); //unblock receive()
}
}
}
}
sp<NfaConn> P2pServer::allocateConnection (PeerToPeer::tJNI_HANDLE jniHandle)
{
AutoMutex mutex(mMutex);
// First, find a free connection block to handle the connection
for (int ii = 0; ii < MAX_NFA_CONNS_PER_SERVER; ii++)
{
if (mServerConn[ii] == NULL)
{
mServerConn[ii] = new NfaConn;
mServerConn[ii]->mJniHandle = jniHandle;
return mServerConn[ii];
}
}
return NULL;
}
/*******************************************************************************
**
** Function: findServerConnection
**
** Description: Find a P2pServer that has the handle.
** nfaConnHandle: NFA connection handle.
**
** Returns: P2pServer object.
**
*******************************************************************************/
sp<NfaConn> P2pServer::findServerConnection (tNFA_HANDLE nfaConnHandle)
{
int jj = 0;
AutoMutex mutex(mMutex);
for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
{
if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mNfaConnHandle == nfaConnHandle) )
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<NfaConn> P2pServer::findServerConnection (PeerToPeer::tJNI_HANDLE jniHandle)
{
int jj = 0;
AutoMutex mutex(mMutex);
for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
{
if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) )
return (mServerConn[jj]);
}
// If here, not found
return (NULL);
}
/*******************************************************************************
**
** Function: removeServerConnection
**
** Description: Find a P2pServer that has the handle.
** nfaConnHandle: NFA connection handle.
**
** Returns: P2pServer object.
**
*******************************************************************************/
bool P2pServer::removeServerConnection (PeerToPeer::tJNI_HANDLE jniHandle)
{
int jj = 0;
AutoMutex mutex(mMutex);
for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
{
if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) ) {
mServerConn[jj] = NULL;
return true;
}
}
// If here, not found
return false;
}
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
/*******************************************************************************
**
** 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)
{
}