/*
 * 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 "PeerToPeer.h"

#include <android-base/stringprintf.h>
#include <base/logging.h>
#include <nativehelper/ScopedLocalRef.h>

#include "JavaClassConstants.h"
#include "NfcJniUtil.h"
#include "llcp_defs.h"
#include "nfc_config.h"

using android::base::StringPrintf;

/* 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();
}  // namespace android

PeerToPeer PeerToPeer::sP2p;
const std::string P2pServer::sSnepServiceName("urn:nfc:sn:snep");

extern bool nfc_debug_enabled;

/*******************************************************************************
**
** 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() {
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("PeerToPeer::initialize");

  if (NfcConfig::hasKey(NAME_P2P_LISTEN_TECH_MASK))
    mP2pListenTechMask = NfcConfig::getUnsigned(NAME_P2P_LISTEN_TECH_MASK);
}

/*******************************************************************************
**
** 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";
  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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) {
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
        "%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);

      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "%s: added new p2p server  index: %d  handle: %u  name: %s", fn, ii,
          jniHandle, serviceName);
      break;
    }
  }
  mMutex.unlock();

  if (pSrv == NULL) {
    LOG(ERROR) << StringPrintf("%s: service name=%s  no free entry", fn,
                               serviceName);
    return (false);
  }

  if (pSrv->registerWithStack()) {
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
        "%s: got new p2p server h=0x%X", fn, pSrv->mNfaP2pServerHandle);
    return (true);
  } else {
    LOG(ERROR) << StringPrintf("%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)) {
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "%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;
    }
  }
  LOG(ERROR) << StringPrintf("%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";
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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) {
    LOG(ERROR) << StringPrintf("%s: jni env is null", fn);
    return;
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: get object class", fn);
  ScopedLocalRef<jclass> tag_cls(e, e->GetObjectClass(nat->cached_P2pDevice));
  if (e->ExceptionCheck()) {
    e->ExceptionClear();
    LOG(ERROR) << StringPrintf("%s: fail get p2p device", fn);
    return;
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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) {
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: p2p initiator", fn);
    e->SetIntField(tag.get(), f, (jint)MODE_P2P_INITIATOR);
  } else {
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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());

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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();
    LOG(ERROR) << StringPrintf("%s: fail notify", fn);
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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";
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", fn);

  JNIEnv* e = NULL;
  ScopedAttach attach(nat->vm, &e);
  if (e == NULL) {
    LOG(ERROR) << StringPrintf("%s: jni env is null", fn);
    return;
  }

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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();
    LOG(ERROR) << StringPrintf("%s: fail notify", fn);
  }

  // let the tag-reading code handle NDEF data event
  android::nativeNfcTag_registerNdefTypeHandler();
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", fn);
}

void PeerToPeer::llcpFirstPacketHandler(nfc_jni_native_data* nat) {
  static const char fn[] = "PeerToPeer::llcpFirstPacketHandler";
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", fn);

  JNIEnv* e = NULL;
  ScopedAttach attach(nat->vm, &e);
  if (e == NULL) {
    LOG(ERROR) << StringPrintf("%s: jni env is null", fn);
    return;
  }

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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();
    LOG(ERROR) << StringPrintf("%s: fail notify", fn);
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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;

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "%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) {
    LOG(ERROR) << StringPrintf("%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";
  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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) {
    LOG(ERROR) << StringPrintf("%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) {
    LOG(ERROR) << StringPrintf("%s: deregister error=0x%X", fn, nfaStat);
  }

  removeServer(jniHandle);

  if (isPollingTempStopped) {
    startRfDiscovery(true);
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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_t miu, uint8_t rw) {
  static const char fn[] = "PeerToPeer::createClient";
  int i = 0;
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "%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) {
    LOG(ERROR) << StringPrintf("%s: fail", fn);
    return (false);
  }

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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) {
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
        "%s: exit; new client jniHandle: %u   NFA Handle: 0x%04x", fn,
        jniHandle, client->mClientConn->mNfaConnHandle);
    return (true);
  } else {
    LOG(ERROR) << StringPrintf(
        "%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;
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "%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;
      }
    }
  }

  LOG(ERROR) << StringPrintf("%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";
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "%s: enter; h: %u  service name=%s", fn, jniHandle, serviceName);
  bool stat = createDataLinkConn(jniHandle, serviceName, 0);
  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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_t destinationSap) {
  static const char fn[] = "PeerToPeer::connectConnOriented";
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "%s: enter; h: %u  dest sap: 0x%X", fn, jniHandle, destinationSap);
  bool stat = createDataLinkConn(jniHandle, NULL, destinationSap);
  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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_t destinationSap) {
  static const char fn[] = "PeerToPeer::createDataLinkConn";
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", fn);
  tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
  sp<P2pClient> pClient = NULL;

  if ((pClient = findClient(jniHandle)) == NULL) {
    LOG(ERROR) << StringPrintf("%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) {
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "%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);
    LOG(ERROR) << StringPrintf("%s: fail; error=0x%X", fn, nfaStat);
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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_t* buffer,
                      uint16_t bufferLen) {
  static const char fn[] = "PeerToPeer::send";
  tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
  sp<NfaConn> pConn = NULL;

  if ((pConn = findConnection(jniHandle)) == NULL) {
    LOG(ERROR) << StringPrintf("%s: can't find connection handle: %u", fn,
                               jniHandle);
    return (false);
  }

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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
    {
      DLOG_IF(INFO, nfc_debug_enabled)
          << StringPrintf("%s: peer disconnected", fn);
      return (false);
    }
  }

  if (nfaStat == NFA_STATUS_OK)
    DLOG_IF(INFO, nfc_debug_enabled)
        << StringPrintf("%s: exit OK; JNI handle: %u  NFA Handle: 0x%04x", fn,
                        jniHandle, pConn->mNfaConnHandle);
  else
    LOG(ERROR) << StringPrintf(
        "%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_t* buffer,
                         uint16_t bufferLen, uint16_t& actualLen) {
  static const char fn[] = "PeerToPeer::receive";
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "%s: enter; jniHandle: %u  bufferLen: %u", fn, jniHandle, bufferLen);
  sp<NfaConn> pConn = NULL;
  tNFA_STATUS stat = NFA_STATUS_FAILED;
  uint32_t actualDataLen2 = 0;
  bool isMoreData = TRUE;
  bool retVal = false;

  if ((pConn = findConnection(jniHandle)) == NULL) {
    LOG(ERROR) << StringPrintf("%s: can't find connection handle: %u", fn,
                               jniHandle);
    return (false);
  }

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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_t)actualDataLen2;
      retVal = true;
      break;
    }
    DLOG_IF(INFO, nfc_debug_enabled)
        << StringPrintf("%s: waiting for data...", fn);
    {
      SyncEventGuard guard(pConn->mReadEvent);
      pConn->mReadEvent.wait();
    }
  }  // while

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%s: enter; jni handle: %u", fn, jniHandle);

  if ((pConn = findConnection(jniHandle)) == NULL) {
    LOG(ERROR) << StringPrintf("%s: can't find connection handle: %u", fn,
                               jniHandle);
    return (false);
  }

  // If this is a client, it may not be connected yet, so unblock it 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) {
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
        "%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)
      LOG(ERROR) << StringPrintf("%s: fail p2p disconnect", fn);
    else
      pConn->mDisconnectingEvent.wait();
  }

  mDisconnectMutex.lock();
  removeConn(jniHandle);
  mDisconnectMutex.unlock();

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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_t PeerToPeer::getRemoteMaxInfoUnit(tJNI_HANDLE jniHandle) {
  static const char fn[] = "PeerToPeer::getRemoteMaxInfoUnit";
  sp<NfaConn> pConn = NULL;

  if ((pConn = findConnection(jniHandle)) == NULL) {
    LOG(ERROR) << StringPrintf("%s: can't find client  jniHandle: %u", fn,
                               jniHandle);
    return 0;
  }
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "%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_t PeerToPeer::getRemoteRecvWindow(tJNI_HANDLE jniHandle) {
  static const char fn[] = "PeerToPeer::getRemoteRecvWindow";
  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%s: client jni handle: %u", fn, jniHandle);
  sp<NfaConn> pConn = NULL;

  if ((pConn = findConnection(jniHandle)) == NULL) {
    LOG(ERROR) << StringPrintf("%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() {
  mP2pListenTechMask = NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_F |
                       NFA_TECHNOLOGY_MASK_A_ACTIVE |
                       NFA_TECHNOLOGY_MASK_F_ACTIVE;
  if (NfcConfig::hasKey("P2P_LISTEN_TECH_MASK"))
    mP2pListenTechMask = NfcConfig::getUnsigned("P2P_LISTEN_TECH_MASK");
}

/*******************************************************************************
**
** 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;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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
      LOG(ERROR) << StringPrintf("%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
      LOG(ERROR) << StringPrintf("%s: fail disable listen; error=0x%X", fn,
                                 nfaStat);
  }
  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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";
  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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
  }
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%s: enter; event=0x%X", fn, p2pEvent);

  switch (p2pEvent) {
    case NFA_P2P_REG_SERVER_EVT:  // NFA_P2pRegisterServer() has started to
                                  // listen
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "%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) {
        LOG(ERROR) << StringPrintf(
            "%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
      DLOG_IF(INFO, nfc_debug_enabled)
          << StringPrintf("%s: NFA_P2P_ACTIVATED_EVT; handle: 0x%04x", fn,
                          eventData->activated.handle);
      break;

    case NFA_P2P_DEACTIVATED_EVT:
      DLOG_IF(INFO, nfc_debug_enabled)
          << StringPrintf("%s: NFA_P2P_DEACTIVATED_EVT; handle: 0x%04x", fn,
                          eventData->activated.handle);
      break;

    case NFA_P2P_CONN_REQ_EVT:
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "%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) {
        LOG(ERROR) << StringPrintf("%s: NFA_P2P_CONN_REQ_EVT; unknown server h",
                                   fn);
        return;
      }
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "%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) {
        LOG(ERROR) << StringPrintf(
            "%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;
        DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
            "%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:
      DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
          "%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:
      DLOG_IF(INFO, nfc_debug_enabled)
          << StringPrintf("%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) {
        LOG(ERROR) << StringPrintf(
            "%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;
        {
          DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
              "%s: NFA_P2P_DISC_EVT; try guard disconn event", fn);
          SyncEventGuard guard3(pConn->mDisconnectingEvent);
          pConn->mDisconnectingEvent.notifyOne();
          DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
              "%s: NFA_P2P_DISC_EVT; notified disconn event", fn);
        }
        {
          DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
              "%s: NFA_P2P_DISC_EVT; try guard congest event", fn);
          SyncEventGuard guard1(pConn->mCongEvent);
          pConn->mCongEvent.notifyOne();  // unblock write (if congested)
          DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
              "%s: NFA_P2P_DISC_EVT; notified congest event", fn);
        }
        {
          DLOG_IF(INFO, nfc_debug_enabled)
              << StringPrintf("%s: NFA_P2P_DISC_EVT; try guard read event", fn);
          SyncEventGuard guard2(pConn->mReadEvent);
          pConn->mReadEvent.notifyOne();  // unblock receive()
          DLOG_IF(INFO, nfc_debug_enabled)
              << StringPrintf("%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) {
        LOG(ERROR) << StringPrintf(
            "%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn,
            eventData->data.handle);
      } else {
        DLOG_IF(INFO, nfc_debug_enabled)
            << StringPrintf("%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) {
        LOG(ERROR) << StringPrintf(
            "%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x",
            fn, eventData->congest.handle);
      } else {
        DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
            "%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:
      DLOG_IF(INFO, nfc_debug_enabled)
          << StringPrintf("%s: unknown event 0x%X ????", fn, p2pEvent);
      break;
  }
  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%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;

  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%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) {
        LOG(ERROR) << StringPrintf(
            "%s: NFA_P2P_REG_CLIENT_EVT: can't find waiting client", fn);
      } else {
        DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
            "%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) {
        LOG(ERROR) << StringPrintf(
            "%s: NFA_P2P_ACTIVATED_EVT: can't find client", fn);
      } else {
        DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
            "%s: NFA_P2P_ACTIVATED_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn,
            eventData->activated.handle, pClient.get());
      }
      break;

    case NFA_P2P_DEACTIVATED_EVT:
      DLOG_IF(INFO, nfc_debug_enabled)
          << StringPrintf("%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) {
        LOG(ERROR) << StringPrintf(
            "%s: NFA_P2P_CONNECTED_EVT: can't find client: 0x%04x", fn,
            eventData->connected.client_handle);
      } else {
        DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
            "%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:
      DLOG_IF(INFO, nfc_debug_enabled)
          << StringPrintf("%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) {
          LOG(ERROR) << StringPrintf(
              "%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;
        {
          DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
              "%s: NFA_P2P_DISC_EVT; try guard disconn event", fn);
          SyncEventGuard guard3(pConn->mDisconnectingEvent);
          pConn->mDisconnectingEvent.notifyOne();
          DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
              "%s: NFA_P2P_DISC_EVT; notified disconn event", fn);
        }
        {
          DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
              "%s: NFA_P2P_DISC_EVT; try guard congest event", fn);
          SyncEventGuard guard1(pConn->mCongEvent);
          pConn->mCongEvent.notifyOne();  // unblock write (if congested)
          DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
              "%s: NFA_P2P_DISC_EVT; notified congest event", fn);
        }
        {
          DLOG_IF(INFO, nfc_debug_enabled)
              << StringPrintf("%s: NFA_P2P_DISC_EVT; try guard read event", fn);
          SyncEventGuard guard2(pConn->mReadEvent);
          pConn->mReadEvent.notifyOne();  // unblock receive()
          DLOG_IF(INFO, nfc_debug_enabled)
              << StringPrintf("%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) {
        LOG(ERROR) << StringPrintf(
            "%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn,
            eventData->data.handle);
      } else {
        DLOG_IF(INFO, nfc_debug_enabled)
            << StringPrintf("%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) {
        LOG(ERROR) << StringPrintf(
            "%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x",
            fn, eventData->congest.handle);
      } else {
        DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
            "%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:
      LOG(ERROR) << StringPrintf("%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_t 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";
  DLOG_IF(INFO, nfc_debug_enabled)
      << StringPrintf("%s: enter; service name: %s  JNI handle: %u", fn,
                      mServiceName.c_str(), mJniHandle);
  tNFA_STATUS stat = NFA_STATUS_OK;
  uint8_t 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)
    LOG(ERROR) << StringPrintf("%s: fail set LLCP config; error=0x%X", fn,
                               stat);

  if (sSnepServiceName.compare(mServiceName) == 0)
    serverSap = 4;  // 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) {
      LOG(ERROR) << StringPrintf("%s: fail register p2p server; error=0x%X", fn,
                                 stat);
      return (false);
    }
    DLOG_IF(INFO, nfc_debug_enabled)
        << StringPrintf("%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) {
    LOG(ERROR) << StringPrintf("%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);
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
        "%s: serverJniHandle: %u; connJniHandle: %u; wait for "
        "incoming connection",
        fn, serverJniHandle, connJniHandle);
    mConnRequestEvent.wait();
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
        "%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);
    DLOG_IF(INFO, nfc_debug_enabled)
        << StringPrintf("%s: no handle assigned", fn);
    return (false);
  }

  if (maxInfoUnit > (int)LLCP_MIU) {
    DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
        "%s: overriding the miu passed by the app(%d) with stack miu(%zu)", fn,
        maxInfoUnit, LLCP_MIU);
    maxInfoUnit = LLCP_MIU;
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "%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) {
    LOG(ERROR) << StringPrintf("%s: fail to accept remote; error=0x%X", fn,
                               nfaStat);
    return (false);
  }

  DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
      "%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) {}