1901 lines
62 KiB
C++
1901 lines
62 KiB
C++
/*
|
|
* 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)
|
|
{
|
|
}
|