• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 /*
18  *  Communicate with a peer using NFC-DEP, LLCP, SNEP.
19  */
20 #include "OverrideLog.h"
21 #include "PeerToPeer.h"
22 #include "NfcJniUtil.h"
23 #include "llcp_defs.h"
24 #include "config.h"
25 #include "JavaClassConstants.h"
26 #include <ScopedLocalRef.h>
27 
28 /* Some older PN544-based solutions would only send the first SYMM back
29  * (as an initiator) after the full LTO (750ms). But our connect timer
30  * starts immediately, and hence we may timeout if the timer is set to
31  * 1000 ms. Worse, this causes us to immediately connect to the NPP
32  * socket, causing concurrency issues in that stack. Increase the default
33  * timeout to 2000 ms, giving us enough time to complete the first connect.
34  */
35 #define LLCP_DATA_LINK_TIMEOUT    2000
36 
37 using namespace android;
38 
39 namespace android
40 {
41     extern void nativeNfcTag_registerNdefTypeHandler ();
42     extern void nativeNfcTag_deregisterNdefTypeHandler ();
43 }
44 
45 
46 PeerToPeer PeerToPeer::sP2p;
47 const std::string P2pServer::sSnepServiceName ("urn:nfc:sn:snep");
48 
49 
50 /*******************************************************************************
51 **
52 ** Function:        PeerToPeer
53 **
54 ** Description:     Initialize member variables.
55 **
56 ** Returns:         None
57 **
58 *******************************************************************************/
PeerToPeer()59 PeerToPeer::PeerToPeer ()
60 :   mRemoteWKS (0),
61     mIsP2pListening (false),
62     mP2pListenTechMask (NFA_TECHNOLOGY_MASK_A
63                         | NFA_TECHNOLOGY_MASK_F
64                         | NFA_TECHNOLOGY_MASK_A_ACTIVE
65                         | NFA_TECHNOLOGY_MASK_F_ACTIVE),
66     mNextJniHandle (1)
67 {
68     memset (mServers, 0, sizeof(mServers));
69     memset (mClients, 0, sizeof(mClients));
70 }
71 
72 
73 /*******************************************************************************
74 **
75 ** Function:        ~PeerToPeer
76 **
77 ** Description:     Free all resources.
78 **
79 ** Returns:         None
80 **
81 *******************************************************************************/
~PeerToPeer()82 PeerToPeer::~PeerToPeer ()
83 {
84 }
85 
86 
87 /*******************************************************************************
88 **
89 ** Function:        getInstance
90 **
91 ** Description:     Get the singleton PeerToPeer object.
92 **
93 ** Returns:         Singleton PeerToPeer object.
94 **
95 *******************************************************************************/
getInstance()96 PeerToPeer& PeerToPeer::getInstance ()
97 {
98     return sP2p;
99 }
100 
101 
102 /*******************************************************************************
103 **
104 ** Function:        initialize
105 **
106 ** Description:     Initialize member variables.
107 **
108 ** Returns:         None
109 **
110 *******************************************************************************/
initialize()111 void PeerToPeer::initialize ()
112 {
113     ALOGD ("PeerToPeer::initialize");
114     unsigned long num = 0;
115 
116     if (GetNumValue ("P2P_LISTEN_TECH_MASK", &num, sizeof (num)))
117         mP2pListenTechMask = num;
118 }
119 
120 
121 /*******************************************************************************
122 **
123 ** Function:        findServerLocked
124 **
125 ** Description:     Find a PeerToPeer object by connection handle.
126 **                  Assumes mMutex is already held
127 **                  nfaP2pServerHandle: Connectin handle.
128 **
129 ** Returns:         PeerToPeer object.
130 **
131 *******************************************************************************/
findServerLocked(tNFA_HANDLE nfaP2pServerHandle)132 sp<P2pServer> PeerToPeer::findServerLocked (tNFA_HANDLE nfaP2pServerHandle)
133 {
134     for (int i = 0; i < sMax; i++)
135     {
136         if ( (mServers[i] != NULL)
137           && (mServers[i]->mNfaP2pServerHandle == nfaP2pServerHandle) )
138         {
139             return (mServers [i]);
140         }
141     }
142 
143     // If here, not found
144     return NULL;
145 }
146 
147 
148 /*******************************************************************************
149 **
150 ** Function:        findServerLocked
151 **
152 ** Description:     Find a PeerToPeer object by connection handle.
153 **                  Assumes mMutex is already held
154 **                  serviceName: service name.
155 **
156 ** Returns:         PeerToPeer object.
157 **
158 *******************************************************************************/
findServerLocked(tJNI_HANDLE jniHandle)159 sp<P2pServer> PeerToPeer::findServerLocked (tJNI_HANDLE jniHandle)
160 {
161     for (int i = 0; i < sMax; i++)
162     {
163         if ( (mServers[i] != NULL)
164           && (mServers[i]->mJniHandle == jniHandle) )
165         {
166             return (mServers [i]);
167         }
168     }
169 
170     // If here, not found
171     return NULL;
172 }
173 
174 
175 /*******************************************************************************
176 **
177 ** Function:        findServerLocked
178 **
179 ** Description:     Find a PeerToPeer object by service name
180 **                  Assumes mMutex is already heldf
181 **                  serviceName: service name.
182 **
183 ** Returns:         PeerToPeer object.
184 **
185 *******************************************************************************/
findServerLocked(const char * serviceName)186 sp<P2pServer> PeerToPeer::findServerLocked (const char *serviceName)
187 {
188     for (int i = 0; i < sMax; i++)
189     {
190         if ( (mServers[i] != NULL) && (mServers[i]->mServiceName.compare(serviceName) == 0) )
191             return (mServers [i]);
192     }
193 
194     // If here, not found
195     return NULL;
196 }
197 
198 
199 /*******************************************************************************
200 **
201 ** Function:        registerServer
202 **
203 ** Description:     Let a server start listening for peer's connection request.
204 **                  jniHandle: Connection handle.
205 **                  serviceName: Server's service name.
206 **
207 ** Returns:         True if ok.
208 **
209 *******************************************************************************/
registerServer(tJNI_HANDLE jniHandle,const char * serviceName)210 bool PeerToPeer::registerServer (tJNI_HANDLE jniHandle, const char *serviceName)
211 {
212     static const char fn [] = "PeerToPeer::registerServer";
213     ALOGD ("%s: enter; service name: %s  JNI handle: %u", fn, serviceName, jniHandle);
214     sp<P2pServer>   pSrv = NULL;
215 
216     mMutex.lock();
217     // Check if already registered
218     if ((pSrv = findServerLocked(serviceName)) != NULL)
219     {
220         ALOGD ("%s: service name=%s  already registered, handle: 0x%04x", fn, serviceName, pSrv->mNfaP2pServerHandle);
221 
222         // Update JNI handle
223         pSrv->mJniHandle = jniHandle;
224         mMutex.unlock();
225         return (true);
226     }
227 
228     for (int ii = 0; ii < sMax; ii++)
229     {
230         if (mServers[ii] == NULL)
231         {
232             pSrv = mServers[ii] = new P2pServer(jniHandle, serviceName);
233 
234             ALOGD ("%s: added new p2p server  index: %d  handle: %u  name: %s", fn, ii, jniHandle, serviceName);
235             break;
236         }
237     }
238     mMutex.unlock();
239 
240     if (pSrv == NULL)
241     {
242         ALOGE ("%s: service name=%s  no free entry", fn, serviceName);
243         return (false);
244     }
245 
246     if (pSrv->registerWithStack()) {
247         ALOGD ("%s: got new p2p server h=0x%X", fn, pSrv->mNfaP2pServerHandle);
248         return (true);
249     } else {
250         ALOGE ("%s: invalid server handle", fn);
251         removeServer (jniHandle);
252         return (false);
253     }
254 }
255 
256 
257 /*******************************************************************************
258 **
259 ** Function:        removeServer
260 **
261 ** Description:     Free resources related to a server.
262 **                  jniHandle: Connection handle.
263 **
264 ** Returns:         None
265 **
266 *******************************************************************************/
removeServer(tJNI_HANDLE jniHandle)267 void PeerToPeer::removeServer (tJNI_HANDLE jniHandle)
268 {
269     static const char fn [] = "PeerToPeer::removeServer";
270 
271     AutoMutex mutex(mMutex);
272 
273     for (int i = 0; i < sMax; i++)
274     {
275         if ( (mServers[i] != NULL) && (mServers[i]->mJniHandle == jniHandle) )
276         {
277             ALOGD ("%s: server jni_handle: %u;  nfa_handle: 0x%04x; name: %s; index=%d",
278                     fn, jniHandle, mServers[i]->mNfaP2pServerHandle, mServers[i]->mServiceName.c_str(), i);
279 
280             mServers [i] = NULL;
281             return;
282         }
283     }
284     ALOGE ("%s: unknown server jni handle: %u", fn, jniHandle);
285 }
286 
287 
288 /*******************************************************************************
289 **
290 ** Function:        llcpActivatedHandler
291 **
292 ** Description:     Receive LLLCP-activated event from stack.
293 **                  nat: JVM-related data.
294 **                  activated: Event data.
295 **
296 ** Returns:         None
297 **
298 *******************************************************************************/
llcpActivatedHandler(nfc_jni_native_data * nat,tNFA_LLCP_ACTIVATED & activated)299 void PeerToPeer::llcpActivatedHandler (nfc_jni_native_data* nat, tNFA_LLCP_ACTIVATED& activated)
300 {
301     static const char fn [] = "PeerToPeer::llcpActivatedHandler";
302     ALOGD ("%s: enter", fn);
303 
304     //no longer need to receive NDEF message from a tag
305     android::nativeNfcTag_deregisterNdefTypeHandler ();
306 
307     mRemoteWKS = activated.remote_wks;
308 
309     JNIEnv* e = NULL;
310     ScopedAttach attach(nat->vm, &e);
311     if (e == NULL)
312     {
313         ALOGE ("%s: jni env is null", fn);
314         return;
315     }
316 
317     ALOGD ("%s: get object class", fn);
318     ScopedLocalRef<jclass> tag_cls(e, e->GetObjectClass(nat->cached_P2pDevice));
319     if (e->ExceptionCheck()) {
320         e->ExceptionClear();
321         ALOGE ("%s: fail get p2p device", fn);
322         return;
323     }
324 
325     ALOGD ("%s: instantiate", fn);
326     /* New target instance */
327     jmethodID ctor = e->GetMethodID(tag_cls.get(), "<init>", "()V");
328     ScopedLocalRef<jobject> tag(e, e->NewObject(tag_cls.get(), ctor));
329 
330     /* Set P2P Target mode */
331     jfieldID f = e->GetFieldID(tag_cls.get(), "mMode", "I");
332 
333     if (activated.is_initiator == TRUE) {
334         ALOGD ("%s: p2p initiator", fn);
335         e->SetIntField(tag.get(), f, (jint) MODE_P2P_INITIATOR);
336     } else {
337         ALOGD ("%s: p2p target", fn);
338         e->SetIntField(tag.get(), f, (jint) MODE_P2P_TARGET);
339     }
340 
341     /* Set tag handle */
342     f = e->GetFieldID(tag_cls.get(), "mHandle", "I");
343     e->SetIntField(tag.get(), f, (jint) 0x1234); // ?? This handle is not used for anything
344 
345     if (nat->tag != NULL) {
346         e->DeleteGlobalRef(nat->tag);
347     }
348     nat->tag = e->NewGlobalRef(tag.get());
349 
350     ALOGD ("%s: notify nfc service", fn);
351 
352     /* Notify manager that new a P2P device was found */
353     e->CallVoidMethod(nat->manager, android::gCachedNfcManagerNotifyLlcpLinkActivation, tag.get());
354     if (e->ExceptionCheck()) {
355         e->ExceptionClear();
356         ALOGE ("%s: fail notify", fn);
357     }
358 
359     ALOGD ("%s: exit", fn);
360 }
361 
362 
363 /*******************************************************************************
364 **
365 ** Function:        llcpDeactivatedHandler
366 **
367 ** Description:     Receive LLLCP-deactivated event from stack.
368 **                  nat: JVM-related data.
369 **                  deactivated: Event data.
370 **
371 ** Returns:         None
372 **
373 *******************************************************************************/
llcpDeactivatedHandler(nfc_jni_native_data * nat,tNFA_LLCP_DEACTIVATED &)374 void PeerToPeer::llcpDeactivatedHandler (nfc_jni_native_data* nat, tNFA_LLCP_DEACTIVATED& /*deactivated*/)
375 {
376     static const char fn [] = "PeerToPeer::llcpDeactivatedHandler";
377     ALOGD ("%s: enter", fn);
378 
379     JNIEnv* e = NULL;
380     ScopedAttach attach(nat->vm, &e);
381     if (e == NULL)
382     {
383         ALOGE ("%s: jni env is null", fn);
384         return;
385     }
386 
387     ALOGD ("%s: notify nfc service", fn);
388     /* Notify manager that the LLCP is lost or deactivated */
389     e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyLlcpLinkDeactivated, nat->tag);
390     if (e->ExceptionCheck())
391     {
392         e->ExceptionClear();
393         ALOGE ("%s: fail notify", fn);
394     }
395 
396     //let the tag-reading code handle NDEF data event
397     android::nativeNfcTag_registerNdefTypeHandler ();
398     ALOGD ("%s: exit", fn);
399 }
400 
llcpFirstPacketHandler(nfc_jni_native_data * nat)401 void PeerToPeer::llcpFirstPacketHandler (nfc_jni_native_data* nat)
402 {
403     static const char fn [] = "PeerToPeer::llcpFirstPacketHandler";
404     ALOGD ("%s: enter", fn);
405 
406     JNIEnv* e = NULL;
407     ScopedAttach attach(nat->vm, &e);
408     if (e == NULL)
409     {
410         ALOGE ("%s: jni env is null", fn);
411         return;
412     }
413 
414     ALOGD ("%s: notify nfc service", fn);
415     /* Notify manager that the LLCP is lost or deactivated */
416     e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyLlcpFirstPacketReceived, nat->tag);
417     if (e->ExceptionCheck())
418     {
419         e->ExceptionClear();
420         ALOGE ("%s: fail notify", fn);
421     }
422 
423     ALOGD ("%s: exit", fn);
424 
425 }
426 /*******************************************************************************
427 **
428 ** Function:        accept
429 **
430 ** Description:     Accept a peer's request to connect.
431 **                  serverJniHandle: Server's handle.
432 **                  connJniHandle: Connection handle.
433 **                  maxInfoUnit: Maximum information unit.
434 **                  recvWindow: Receive window size.
435 **
436 ** Returns:         True if ok.
437 **
438 *******************************************************************************/
accept(tJNI_HANDLE serverJniHandle,tJNI_HANDLE connJniHandle,int maxInfoUnit,int recvWindow)439 bool PeerToPeer::accept (tJNI_HANDLE serverJniHandle, tJNI_HANDLE connJniHandle, int maxInfoUnit, int recvWindow)
440 {
441     static const char fn [] = "PeerToPeer::accept";
442     sp<P2pServer> pSrv = NULL;
443 
444     ALOGD ("%s: enter; server jni handle: %u; conn jni handle: %u; maxInfoUnit: %d; recvWindow: %d", fn,
445             serverJniHandle, connJniHandle, maxInfoUnit, recvWindow);
446 
447     mMutex.lock();
448     if ((pSrv = findServerLocked (serverJniHandle)) == NULL)
449     {
450         ALOGE ("%s: unknown server jni handle: %u", fn, serverJniHandle);
451         mMutex.unlock();
452         return (false);
453     }
454     mMutex.unlock();
455 
456     return pSrv->accept(serverJniHandle, connJniHandle, maxInfoUnit, recvWindow);
457 }
458 
459 
460 /*******************************************************************************
461 **
462 ** Function:        deregisterServer
463 **
464 ** Description:     Stop a P2pServer from listening for peer.
465 **
466 ** Returns:         True if ok.
467 **
468 *******************************************************************************/
deregisterServer(tJNI_HANDLE jniHandle)469 bool PeerToPeer::deregisterServer (tJNI_HANDLE jniHandle)
470 {
471     static const char fn [] = "PeerToPeer::deregisterServer";
472     ALOGD ("%s: enter; JNI handle: %u", fn, jniHandle);
473     tNFA_STATUS     nfaStat = NFA_STATUS_FAILED;
474     sp<P2pServer>   pSrv = NULL;
475 
476     mMutex.lock();
477     if ((pSrv = findServerLocked (jniHandle)) == NULL)
478     {
479         ALOGE ("%s: unknown service handle: %u", fn, jniHandle);
480         mMutex.unlock();
481         return (false);
482     }
483     mMutex.unlock();
484 
485     {
486         // Server does not call NFA_P2pDisconnect(), so unblock the accept()
487         SyncEventGuard guard (pSrv->mConnRequestEvent);
488         pSrv->mConnRequestEvent.notifyOne();
489     }
490 
491     nfaStat = NFA_P2pDeregister (pSrv->mNfaP2pServerHandle);
492     if (nfaStat != NFA_STATUS_OK)
493     {
494         ALOGE ("%s: deregister error=0x%X", fn, nfaStat);
495     }
496 
497     removeServer (jniHandle);
498 
499     ALOGD ("%s: exit", fn);
500     return true;
501 }
502 
503 
504 /*******************************************************************************
505 **
506 ** Function:        createClient
507 **
508 ** Description:     Create a P2pClient object for a new out-bound connection.
509 **                  jniHandle: Connection handle.
510 **                  miu: Maximum information unit.
511 **                  rw: Receive window size.
512 **
513 ** Returns:         True if ok.
514 **
515 *******************************************************************************/
createClient(tJNI_HANDLE jniHandle,UINT16 miu,UINT8 rw)516 bool PeerToPeer::createClient (tJNI_HANDLE jniHandle, UINT16 miu, UINT8 rw)
517 {
518     static const char fn [] = "PeerToPeer::createClient";
519     int i = 0;
520     ALOGD ("%s: enter: jni h: %u  miu: %u  rw: %u", fn, jniHandle, miu, rw);
521 
522     mMutex.lock();
523     sp<P2pClient> client = NULL;
524     for (i = 0; i < sMax; i++)
525     {
526         if (mClients[i] == NULL)
527         {
528             mClients [i] = client = new P2pClient();
529 
530             mClients [i]->mClientConn->mJniHandle   = jniHandle;
531             mClients [i]->mClientConn->mMaxInfoUnit = miu;
532             mClients [i]->mClientConn->mRecvWindow  = rw;
533             break;
534         }
535     }
536     mMutex.unlock();
537 
538     if (client == NULL)
539     {
540         ALOGE ("%s: fail", fn);
541         return (false);
542     }
543 
544     ALOGD ("%s: pClient: 0x%p  assigned for client jniHandle: %u", fn, client.get(), jniHandle);
545 
546     {
547         SyncEventGuard guard (mClients[i]->mRegisteringEvent);
548         NFA_P2pRegisterClient (NFA_P2P_DLINK_TYPE, nfaClientCallback);
549         mClients[i]->mRegisteringEvent.wait(); //wait for NFA_P2P_REG_CLIENT_EVT
550     }
551 
552     if (mClients[i]->mNfaP2pClientHandle != NFA_HANDLE_INVALID)
553     {
554         ALOGD ("%s: exit; new client jniHandle: %u   NFA Handle: 0x%04x", fn, jniHandle, client->mClientConn->mNfaConnHandle);
555         return (true);
556     }
557     else
558     {
559         ALOGE ("%s: FAILED; new client jniHandle: %u   NFA Handle: 0x%04x", fn, jniHandle, client->mClientConn->mNfaConnHandle);
560         removeConn (jniHandle);
561         return (false);
562     }
563 }
564 
565 
566 /*******************************************************************************
567 **
568 ** Function:        removeConn
569 **
570 ** Description:     Free resources related to a connection.
571 **                  jniHandle: Connection handle.
572 **
573 ** Returns:         None
574 **
575 *******************************************************************************/
removeConn(tJNI_HANDLE jniHandle)576 void PeerToPeer::removeConn(tJNI_HANDLE jniHandle)
577 {
578     static const char fn[] = "PeerToPeer::removeConn";
579 
580     AutoMutex mutex(mMutex);
581     // If the connection is a for a client, delete the client itself
582     for (size_t ii = 0; ii < sMax; ii++)
583     {
584         if ((mClients[ii] != NULL) && (mClients[ii]->mClientConn->mJniHandle == jniHandle))
585         {
586             if (mClients[ii]->mNfaP2pClientHandle != NFA_HANDLE_INVALID)
587                 NFA_P2pDeregister (mClients[ii]->mNfaP2pClientHandle);
588 
589             mClients[ii] = NULL;
590             ALOGD ("%s: deleted client handle: %u  index: %u", fn, jniHandle, ii);
591             return;
592         }
593     }
594 
595     // If the connection is for a server, just delete the connection
596     for (size_t ii = 0; ii < sMax; ii++)
597     {
598         if (mServers[ii] != NULL)
599         {
600             if (mServers[ii]->removeServerConnection(jniHandle)) {
601                 return;
602             }
603         }
604     }
605 
606     ALOGE ("%s: could not find handle: %u", fn, jniHandle);
607 }
608 
609 
610 /*******************************************************************************
611 **
612 ** Function:        connectConnOriented
613 **
614 ** Description:     Estabish a connection-oriented connection to a peer.
615 **                  jniHandle: Connection handle.
616 **                  serviceName: Peer's service name.
617 **
618 ** Returns:         True if ok.
619 **
620 *******************************************************************************/
connectConnOriented(tJNI_HANDLE jniHandle,const char * serviceName)621 bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, const char* serviceName)
622 {
623     static const char fn [] = "PeerToPeer::connectConnOriented";
624     ALOGD ("%s: enter; h: %u  service name=%s", fn, jniHandle, serviceName);
625     bool stat = createDataLinkConn (jniHandle, serviceName, 0);
626     ALOGD ("%s: exit; h: %u  stat: %u", fn, jniHandle, stat);
627     return stat;
628 }
629 
630 
631 /*******************************************************************************
632 **
633 ** Function:        connectConnOriented
634 **
635 ** Description:     Estabish a connection-oriented connection to a peer.
636 **                  jniHandle: Connection handle.
637 **                  destinationSap: Peer's service access point.
638 **
639 ** Returns:         True if ok.
640 **
641 *******************************************************************************/
connectConnOriented(tJNI_HANDLE jniHandle,UINT8 destinationSap)642 bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, UINT8 destinationSap)
643 {
644     static const char fn [] = "PeerToPeer::connectConnOriented";
645     ALOGD ("%s: enter; h: %u  dest sap: 0x%X", fn, jniHandle, destinationSap);
646     bool stat = createDataLinkConn (jniHandle, NULL, destinationSap);
647     ALOGD ("%s: exit; h: %u  stat: %u", fn, jniHandle, stat);
648     return stat;
649 }
650 
651 
652 /*******************************************************************************
653 **
654 ** Function:        createDataLinkConn
655 **
656 ** Description:     Estabish a connection-oriented connection to a peer.
657 **                  jniHandle: Connection handle.
658 **                  serviceName: Peer's service name.
659 **                  destinationSap: Peer's service access point.
660 **
661 ** Returns:         True if ok.
662 **
663 *******************************************************************************/
createDataLinkConn(tJNI_HANDLE jniHandle,const char * serviceName,UINT8 destinationSap)664 bool PeerToPeer::createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceName, UINT8 destinationSap)
665 {
666     static const char fn [] = "PeerToPeer::createDataLinkConn";
667     ALOGD ("%s: enter", fn);
668     tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
669     sp<P2pClient>   pClient = NULL;
670 
671     if ((pClient = findClient (jniHandle)) == NULL)
672     {
673         ALOGE ("%s: can't find client, JNI handle: %u", fn, jniHandle);
674         return (false);
675     }
676 
677     {
678         SyncEventGuard guard (pClient->mConnectingEvent);
679         pClient->mIsConnecting = true;
680 
681         if (serviceName)
682             nfaStat = NFA_P2pConnectByName (pClient->mNfaP2pClientHandle,
683                     const_cast<char*>(serviceName), pClient->mClientConn->mMaxInfoUnit,
684                     pClient->mClientConn->mRecvWindow);
685         else if (destinationSap)
686             nfaStat = NFA_P2pConnectBySap (pClient->mNfaP2pClientHandle, destinationSap,
687                     pClient->mClientConn->mMaxInfoUnit, pClient->mClientConn->mRecvWindow);
688         if (nfaStat == NFA_STATUS_OK)
689         {
690             ALOGD ("%s: wait for connected event  mConnectingEvent: 0x%p", fn, pClient.get());
691             pClient->mConnectingEvent.wait();
692         }
693     }
694 
695     if (nfaStat == NFA_STATUS_OK)
696     {
697         if (pClient->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID)
698         {
699             removeConn (jniHandle);
700             nfaStat = NFA_STATUS_FAILED;
701         }
702         else
703             pClient->mIsConnecting = false;
704     }
705     else
706     {
707         removeConn (jniHandle);
708         ALOGE ("%s: fail; error=0x%X", fn, nfaStat);
709     }
710 
711     ALOGD ("%s: exit", fn);
712     return nfaStat == NFA_STATUS_OK;
713 }
714 
715 
716 /*******************************************************************************
717 **
718 ** Function:        findClient
719 **
720 ** Description:     Find a PeerToPeer object with a client connection handle.
721 **                  nfaConnHandle: Connection handle.
722 **
723 ** Returns:         PeerToPeer object.
724 **
725 *******************************************************************************/
findClient(tNFA_HANDLE nfaConnHandle)726 sp<P2pClient> PeerToPeer::findClient (tNFA_HANDLE nfaConnHandle)
727 {
728     AutoMutex mutex(mMutex);
729     for (int i = 0; i < sMax; i++)
730     {
731         if ((mClients[i] != NULL) && (mClients[i]->mNfaP2pClientHandle == nfaConnHandle))
732             return (mClients[i]);
733     }
734     return (NULL);
735 }
736 
737 
738 /*******************************************************************************
739 **
740 ** Function:        findClient
741 **
742 ** Description:     Find a PeerToPeer object with a client connection handle.
743 **                  jniHandle: Connection handle.
744 **
745 ** Returns:         PeerToPeer object.
746 **
747 *******************************************************************************/
findClient(tJNI_HANDLE jniHandle)748 sp<P2pClient> PeerToPeer::findClient (tJNI_HANDLE jniHandle)
749 {
750     AutoMutex mutex(mMutex);
751     for (int i = 0; i < sMax; i++)
752     {
753         if ((mClients[i] != NULL) && (mClients[i]->mClientConn->mJniHandle == jniHandle))
754             return (mClients[i]);
755     }
756     return (NULL);
757 }
758 
759 
760 /*******************************************************************************
761 **
762 ** Function:        findClientCon
763 **
764 ** Description:     Find a PeerToPeer object with a client connection handle.
765 **                  nfaConnHandle: Connection handle.
766 **
767 ** Returns:         PeerToPeer object.
768 **
769 *******************************************************************************/
findClientCon(tNFA_HANDLE nfaConnHandle)770 sp<P2pClient> PeerToPeer::findClientCon (tNFA_HANDLE nfaConnHandle)
771 {
772     AutoMutex mutex(mMutex);
773     for (int i = 0; i < sMax; i++)
774     {
775         if ((mClients[i] != NULL) && (mClients[i]->mClientConn->mNfaConnHandle == nfaConnHandle))
776             return (mClients[i]);
777     }
778     return (NULL);
779 }
780 
781 
782 /*******************************************************************************
783 **
784 ** Function:        findConnection
785 **
786 ** Description:     Find a PeerToPeer object with a connection handle.
787 **                  nfaConnHandle: Connection handle.
788 **
789 ** Returns:         PeerToPeer object.
790 **
791 *******************************************************************************/
findConnection(tNFA_HANDLE nfaConnHandle)792 sp<NfaConn> PeerToPeer::findConnection (tNFA_HANDLE nfaConnHandle)
793 {
794     AutoMutex mutex(mMutex);
795     // First, look through all the client control blocks
796     for (size_t ii = 0; ii < sMax; ii++)
797     {
798         if ( (mClients[ii] != NULL)
799            && (mClients[ii]->mClientConn->mNfaConnHandle == nfaConnHandle) ) {
800             return mClients[ii]->mClientConn;
801         }
802     }
803 
804     // Not found yet. Look through all the server control blocks
805     for (size_t ii = 0; ii < sMax; ii++)
806     {
807         if (mServers[ii] != NULL)
808         {
809             sp<NfaConn> conn = mServers[ii]->findServerConnection(nfaConnHandle);
810             if (conn != NULL) {
811                 return conn;
812             }
813         }
814     }
815 
816     // Not found...
817     return NULL;
818 }
819 
820 
821 /*******************************************************************************
822 **
823 ** Function:        findConnection
824 **
825 ** Description:     Find a PeerToPeer object with a connection handle.
826 **                  jniHandle: Connection handle.
827 **
828 ** Returns:         PeerToPeer object.
829 **
830 *******************************************************************************/
findConnection(tJNI_HANDLE jniHandle)831 sp<NfaConn> PeerToPeer::findConnection (tJNI_HANDLE jniHandle)
832 {
833     AutoMutex mutex(mMutex);
834     // First, look through all the client control blocks
835     for (size_t ii = 0; ii < sMax; ii++)
836     {
837         if ( (mClients[ii] != NULL)
838           && (mClients[ii]->mClientConn->mJniHandle == jniHandle) ) {
839             return mClients[ii]->mClientConn;
840         }
841     }
842 
843     // Not found yet. Look through all the server control blocks
844     for (size_t ii = 0; ii < sMax; ii++)
845     {
846         if (mServers[ii] != NULL)
847         {
848             sp<NfaConn> conn = mServers[ii]->findServerConnection(jniHandle);
849             if (conn != NULL) {
850                 return conn;
851             }
852         }
853     }
854 
855     // Not found...
856     return NULL;
857 }
858 
859 
860 /*******************************************************************************
861 **
862 ** Function:        send
863 **
864 ** Description:     Send data to peer.
865 **                  jniHandle: Handle of connection.
866 **                  buffer: Buffer of data.
867 **                  bufferLen: Length of data.
868 **
869 ** Returns:         True if ok.
870 **
871 *******************************************************************************/
send(tJNI_HANDLE jniHandle,UINT8 * buffer,UINT16 bufferLen)872 bool PeerToPeer::send (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 bufferLen)
873 {
874     static const char fn [] = "PeerToPeer::send";
875     tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
876     sp<NfaConn>     pConn =  NULL;
877 
878     if ((pConn = findConnection (jniHandle)) == NULL)
879     {
880         ALOGE ("%s: can't find connection handle: %u", fn, jniHandle);
881         return (false);
882     }
883 
884     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: send data; jniHandle: %u  nfaHandle: 0x%04X",
885             fn, pConn->mJniHandle, pConn->mNfaConnHandle);
886 
887     while (true)
888     {
889         SyncEventGuard guard (pConn->mCongEvent);
890         nfaStat = NFA_P2pSendData (pConn->mNfaConnHandle, bufferLen, buffer);
891         if (nfaStat == NFA_STATUS_CONGESTED)
892             pConn->mCongEvent.wait (); //wait for NFA_P2P_CONGEST_EVT
893         else
894             break;
895 
896         if (pConn->mNfaConnHandle == NFA_HANDLE_INVALID) //peer already disconnected
897         {
898             ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: peer disconnected", fn);
899             return (false);
900         }
901     }
902 
903     if (nfaStat == NFA_STATUS_OK)
904         ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit OK; JNI handle: %u  NFA Handle: 0x%04x", fn, jniHandle, pConn->mNfaConnHandle);
905     else
906         ALOGE ("%s: Data not sent; JNI handle: %u  NFA Handle: 0x%04x  error: 0x%04x",
907               fn, jniHandle, pConn->mNfaConnHandle, nfaStat);
908 
909     return nfaStat == NFA_STATUS_OK;
910 }
911 
912 
913 /*******************************************************************************
914 **
915 ** Function:        receive
916 **
917 ** Description:     Receive data from peer.
918 **                  jniHandle: Handle of connection.
919 **                  buffer: Buffer to store data.
920 **                  bufferLen: Max length of buffer.
921 **                  actualLen: Actual length received.
922 **
923 ** Returns:         True if ok.
924 **
925 *******************************************************************************/
receive(tJNI_HANDLE jniHandle,UINT8 * buffer,UINT16 bufferLen,UINT16 & actualLen)926 bool PeerToPeer::receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen, UINT16& actualLen)
927 {
928     static const char fn [] = "PeerToPeer::receive";
929     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; jniHandle: %u  bufferLen: %u", fn, jniHandle, bufferLen);
930     sp<NfaConn> pConn = NULL;
931     tNFA_STATUS stat = NFA_STATUS_FAILED;
932     UINT32 actualDataLen2 = 0;
933     BOOLEAN isMoreData = TRUE;
934     bool retVal = false;
935 
936     if ((pConn = findConnection (jniHandle)) == NULL)
937     {
938         ALOGE ("%s: can't find connection handle: %u", fn, jniHandle);
939         return (false);
940     }
941 
942     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: jniHandle: %u  nfaHandle: 0x%04X  buf len=%u", fn, pConn->mJniHandle, pConn->mNfaConnHandle, bufferLen);
943 
944     while (pConn->mNfaConnHandle != NFA_HANDLE_INVALID)
945     {
946         //NFA_P2pReadData() is synchronous
947         stat = NFA_P2pReadData (pConn->mNfaConnHandle, bufferLen, &actualDataLen2, buffer, &isMoreData);
948         if ((stat == NFA_STATUS_OK) && (actualDataLen2 > 0)) //received some data
949         {
950             actualLen = (UINT16) actualDataLen2;
951             retVal = true;
952             break;
953         }
954         ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: waiting for data...", fn);
955         {
956             SyncEventGuard guard (pConn->mReadEvent);
957             pConn->mReadEvent.wait();
958         }
959     } //while
960 
961     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);
962     return retVal;
963 }
964 
965 
966 /*******************************************************************************
967 **
968 ** Function:        disconnectConnOriented
969 **
970 ** Description:     Disconnect a connection-oriented connection with peer.
971 **                  jniHandle: Handle of connection.
972 **
973 ** Returns:         True if ok.
974 **
975 *******************************************************************************/
disconnectConnOriented(tJNI_HANDLE jniHandle)976 bool PeerToPeer::disconnectConnOriented (tJNI_HANDLE jniHandle)
977 {
978     static const char fn [] = "PeerToPeer::disconnectConnOriented";
979     tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
980     sp<P2pClient>   pClient = NULL;
981     sp<NfaConn>     pConn = NULL;
982 
983     ALOGD ("%s: enter; jni handle: %u", fn, jniHandle);
984 
985     if ((pConn = findConnection(jniHandle)) == NULL)
986     {
987         ALOGE ("%s: can't find connection handle: %u", fn, jniHandle);
988         return (false);
989     }
990 
991     // If this is a client, he may not be connected yet, so unblock him just in case
992     if ( ((pClient = findClient(jniHandle)) != NULL) && (pClient->mIsConnecting) )
993     {
994         SyncEventGuard guard (pClient->mConnectingEvent);
995         pClient->mConnectingEvent.notifyOne();
996         return (true);
997     }
998 
999     {
1000         SyncEventGuard guard1 (pConn->mCongEvent);
1001         pConn->mCongEvent.notifyOne (); //unblock send() if congested
1002     }
1003     {
1004         SyncEventGuard guard2 (pConn->mReadEvent);
1005         pConn->mReadEvent.notifyOne (); //unblock receive()
1006     }
1007 
1008     if (pConn->mNfaConnHandle != NFA_HANDLE_INVALID)
1009     {
1010         ALOGD ("%s: try disconn nfa h=0x%04X", fn, pConn->mNfaConnHandle);
1011         SyncEventGuard guard (pConn->mDisconnectingEvent);
1012         nfaStat = NFA_P2pDisconnect (pConn->mNfaConnHandle, FALSE);
1013 
1014         if (nfaStat != NFA_STATUS_OK)
1015             ALOGE ("%s: fail p2p disconnect", fn);
1016         else
1017             pConn->mDisconnectingEvent.wait();
1018     }
1019 
1020     mDisconnectMutex.lock ();
1021     removeConn (jniHandle);
1022     mDisconnectMutex.unlock ();
1023 
1024     ALOGD ("%s: exit; jni handle: %u", fn, jniHandle);
1025     return nfaStat == NFA_STATUS_OK;
1026 }
1027 
1028 
1029 /*******************************************************************************
1030 **
1031 ** Function:        getRemoteMaxInfoUnit
1032 **
1033 ** Description:     Get peer's max information unit.
1034 **                  jniHandle: Handle of the connection.
1035 **
1036 ** Returns:         Peer's max information unit.
1037 **
1038 *******************************************************************************/
getRemoteMaxInfoUnit(tJNI_HANDLE jniHandle)1039 UINT16 PeerToPeer::getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle)
1040 {
1041     static const char fn [] = "PeerToPeer::getRemoteMaxInfoUnit";
1042     sp<NfaConn> pConn = NULL;
1043 
1044     if ((pConn = findConnection(jniHandle)) == NULL)
1045     {
1046         ALOGE ("%s: can't find client  jniHandle: %u", fn, jniHandle);
1047         return 0;
1048     }
1049     ALOGD ("%s: jniHandle: %u   MIU: %u", fn, jniHandle, pConn->mRemoteMaxInfoUnit);
1050     return (pConn->mRemoteMaxInfoUnit);
1051 }
1052 
1053 
1054 /*******************************************************************************
1055 **
1056 ** Function:        getRemoteRecvWindow
1057 **
1058 ** Description:     Get peer's receive window size.
1059 **                  jniHandle: Handle of the connection.
1060 **
1061 ** Returns:         Peer's receive window size.
1062 **
1063 *******************************************************************************/
getRemoteRecvWindow(tJNI_HANDLE jniHandle)1064 UINT8 PeerToPeer::getRemoteRecvWindow (tJNI_HANDLE jniHandle)
1065 {
1066     static const char fn [] = "PeerToPeer::getRemoteRecvWindow";
1067     ALOGD ("%s: client jni handle: %u", fn, jniHandle);
1068     sp<NfaConn> pConn = NULL;
1069 
1070     if ((pConn = findConnection(jniHandle)) == NULL)
1071     {
1072         ALOGE ("%s: can't find client", fn);
1073         return 0;
1074     }
1075     return pConn->mRemoteRecvWindow;
1076 }
1077 
1078 /*******************************************************************************
1079 **
1080 ** Function:        setP2pListenMask
1081 **
1082 ** Description:     Sets the p2p listen technology mask.
1083 **                  p2pListenMask: the p2p listen mask to be set?
1084 **
1085 ** Returns:         None
1086 **
1087 *******************************************************************************/
setP2pListenMask(tNFA_TECHNOLOGY_MASK p2pListenMask)1088 void PeerToPeer::setP2pListenMask (tNFA_TECHNOLOGY_MASK p2pListenMask) {
1089     mP2pListenTechMask = p2pListenMask;
1090 }
1091 
1092 /*******************************************************************************
1093 **
1094 ** Function:        enableP2pListening
1095 **
1096 ** Description:     Start/stop polling/listening to peer that supports P2P.
1097 **                  isEnable: Is enable polling/listening?
1098 **
1099 ** Returns:         None
1100 **
1101 *******************************************************************************/
enableP2pListening(bool isEnable)1102 void PeerToPeer::enableP2pListening (bool isEnable)
1103 {
1104     static const char    fn []   = "PeerToPeer::enableP2pListening";
1105     tNFA_STATUS          nfaStat = NFA_STATUS_FAILED;
1106 
1107     ALOGD ("%s: enter isEnable: %u  mIsP2pListening: %u", fn, isEnable, mIsP2pListening);
1108 
1109     // If request to enable P2P listening, and we were not already listening
1110     if ( (isEnable == true) && (mIsP2pListening == false) && (mP2pListenTechMask != 0) )
1111     {
1112         SyncEventGuard guard (mSetTechEvent);
1113         if ((nfaStat = NFA_SetP2pListenTech (mP2pListenTechMask)) == NFA_STATUS_OK)
1114         {
1115             mSetTechEvent.wait ();
1116             mIsP2pListening = true;
1117         }
1118         else
1119             ALOGE ("%s: fail enable listen; error=0x%X", fn, nfaStat);
1120     }
1121     else if ( (isEnable == false) && (mIsP2pListening == true) )
1122     {
1123         SyncEventGuard guard (mSetTechEvent);
1124         // Request to disable P2P listening, check if it was enabled
1125         if ((nfaStat = NFA_SetP2pListenTech(0)) == NFA_STATUS_OK)
1126         {
1127             mSetTechEvent.wait ();
1128             mIsP2pListening = false;
1129         }
1130         else
1131             ALOGE ("%s: fail disable listen; error=0x%X", fn, nfaStat);
1132     }
1133     ALOGD ("%s: exit; mIsP2pListening: %u", fn, mIsP2pListening);
1134 }
1135 
1136 
1137 /*******************************************************************************
1138 **
1139 ** Function:        handleNfcOnOff
1140 **
1141 ** Description:     Handle events related to turning NFC on/off by the user.
1142 **                  isOn: Is NFC turning on?
1143 **
1144 ** Returns:         None
1145 **
1146 *******************************************************************************/
handleNfcOnOff(bool isOn)1147 void PeerToPeer::handleNfcOnOff (bool isOn)
1148 {
1149     static const char fn [] = "PeerToPeer::handleNfcOnOff";
1150     ALOGD ("%s: enter; is on=%u", fn, isOn);
1151 
1152     mIsP2pListening = false;            // In both cases, P2P will not be listening
1153 
1154     AutoMutex mutex(mMutex);
1155     if (isOn)
1156     {
1157         // Start with no clients or servers
1158         memset (mServers, 0, sizeof(mServers));
1159         memset (mClients, 0, sizeof(mClients));
1160     }
1161     else
1162     {
1163         // Disconnect through all the clients
1164         for (size_t ii = 0; ii < sMax; ii++)
1165         {
1166             if (mClients[ii] != NULL)
1167             {
1168                 if (mClients[ii]->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID)
1169                 {
1170                     SyncEventGuard guard (mClients[ii]->mConnectingEvent);
1171                     mClients[ii]->mConnectingEvent.notifyOne();
1172                 }
1173                 else
1174                 {
1175                     mClients[ii]->mClientConn->mNfaConnHandle = NFA_HANDLE_INVALID;
1176                     {
1177                         SyncEventGuard guard1 (mClients[ii]->mClientConn->mCongEvent);
1178                         mClients[ii]->mClientConn->mCongEvent.notifyOne (); //unblock send()
1179                     }
1180                     {
1181                         SyncEventGuard guard2 (mClients[ii]->mClientConn->mReadEvent);
1182                         mClients[ii]->mClientConn->mReadEvent.notifyOne (); //unblock receive()
1183                     }
1184                 }
1185             }
1186         } //loop
1187 
1188         // Now look through all the server control blocks
1189         for (size_t ii = 0; ii < sMax; ii++)
1190         {
1191             if (mServers[ii] != NULL)
1192             {
1193                 mServers[ii]->unblockAll();
1194             }
1195         } //loop
1196 
1197     }
1198     ALOGD ("%s: exit", fn);
1199 }
1200 
1201 
1202 /*******************************************************************************
1203 **
1204 ** Function:        nfaServerCallback
1205 **
1206 ** Description:     Receive LLCP-related events from the stack.
1207 **                  p2pEvent: Event code.
1208 **                  eventData: Event data.
1209 **
1210 ** Returns:         None
1211 **
1212 *******************************************************************************/
nfaServerCallback(tNFA_P2P_EVT p2pEvent,tNFA_P2P_EVT_DATA * eventData)1213 void PeerToPeer::nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* eventData)
1214 {
1215     static const char fn [] = "PeerToPeer::nfaServerCallback";
1216     sp<P2pServer>   pSrv = NULL;
1217     sp<NfaConn>     pConn = NULL;
1218 
1219     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; event=0x%X", fn, p2pEvent);
1220 
1221     switch (p2pEvent)
1222     {
1223     case NFA_P2P_REG_SERVER_EVT:  // NFA_P2pRegisterServer() has started to listen
1224         ALOGD ("%s: NFA_P2P_REG_SERVER_EVT; handle: 0x%04x; service sap=0x%02x  name: %s", fn,
1225               eventData->reg_server.server_handle, eventData->reg_server.server_sap, eventData->reg_server.service_name);
1226 
1227         sP2p.mMutex.lock();
1228         pSrv = sP2p.findServerLocked(eventData->reg_server.service_name);
1229         sP2p.mMutex.unlock();
1230         if (pSrv == NULL)
1231         {
1232             ALOGE ("%s: NFA_P2P_REG_SERVER_EVT for unknown service: %s", fn, eventData->reg_server.service_name);
1233         }
1234         else
1235         {
1236             SyncEventGuard guard (pSrv->mRegServerEvent);
1237             pSrv->mNfaP2pServerHandle = eventData->reg_server.server_handle;
1238             pSrv->mRegServerEvent.notifyOne(); //unblock registerServer()
1239         }
1240         break;
1241 
1242     case NFA_P2P_ACTIVATED_EVT: //remote device has activated
1243         ALOGD ("%s: NFA_P2P_ACTIVATED_EVT; handle: 0x%04x", fn, eventData->activated.handle);
1244         break;
1245 
1246     case NFA_P2P_DEACTIVATED_EVT:
1247         ALOGD ("%s: NFA_P2P_DEACTIVATED_EVT; handle: 0x%04x", fn, eventData->activated.handle);
1248         break;
1249 
1250     case NFA_P2P_CONN_REQ_EVT:
1251         ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; nfa server h=0x%04x; nfa conn h=0x%04x; remote sap=0x%02x", fn,
1252                 eventData->conn_req.server_handle, eventData->conn_req.conn_handle, eventData->conn_req.remote_sap);
1253 
1254         sP2p.mMutex.lock();
1255         pSrv = sP2p.findServerLocked(eventData->conn_req.server_handle);
1256         sP2p.mMutex.unlock();
1257         if (pSrv == NULL)
1258         {
1259             ALOGE ("%s: NFA_P2P_CONN_REQ_EVT; unknown server h", fn);
1260             return;
1261         }
1262         ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u", fn, pSrv->mJniHandle);
1263 
1264         // Look for a connection block that is waiting (handle invalid)
1265         if ((pConn = pSrv->findServerConnection((tNFA_HANDLE) NFA_HANDLE_INVALID)) == NULL)
1266         {
1267             ALOGE ("%s: NFA_P2P_CONN_REQ_EVT; server not listening", fn);
1268         }
1269         else
1270         {
1271             SyncEventGuard guard (pSrv->mConnRequestEvent);
1272             pConn->mNfaConnHandle = eventData->conn_req.conn_handle;
1273             pConn->mRemoteMaxInfoUnit = eventData->conn_req.remote_miu;
1274             pConn->mRemoteRecvWindow = eventData->conn_req.remote_rw;
1275             ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u; conn jni h=%u; notify conn req", fn, pSrv->mJniHandle, pConn->mJniHandle);
1276             pSrv->mConnRequestEvent.notifyOne(); //unblock accept()
1277         }
1278         break;
1279 
1280     case NFA_P2P_CONNECTED_EVT:
1281         ALOGD ("%s: NFA_P2P_CONNECTED_EVT; h=0x%x  remote sap=0x%X", fn,
1282                 eventData->connected.client_handle, eventData->connected.remote_sap);
1283         break;
1284 
1285     case NFA_P2P_DISC_EVT:
1286         ALOGD ("%s: NFA_P2P_DISC_EVT; h=0x%04x; reason=0x%X", fn, eventData->disc.handle, eventData->disc.reason);
1287         // Look for the connection block
1288         if ((pConn = sP2p.findConnection(eventData->disc.handle)) == NULL)
1289         {
1290             ALOGE ("%s: NFA_P2P_DISC_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->disc.handle);
1291         }
1292         else
1293         {
1294             sP2p.mDisconnectMutex.lock ();
1295             pConn->mNfaConnHandle = NFA_HANDLE_INVALID;
1296             {
1297                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard disconn event", fn);
1298                 SyncEventGuard guard3 (pConn->mDisconnectingEvent);
1299                 pConn->mDisconnectingEvent.notifyOne ();
1300                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified disconn event", fn);
1301             }
1302             {
1303                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard congest event", fn);
1304                 SyncEventGuard guard1 (pConn->mCongEvent);
1305                 pConn->mCongEvent.notifyOne (); //unblock write (if congested)
1306                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified congest event", fn);
1307             }
1308             {
1309                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard read event", fn);
1310                 SyncEventGuard guard2 (pConn->mReadEvent);
1311                 pConn->mReadEvent.notifyOne (); //unblock receive()
1312                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified read event", fn);
1313             }
1314             sP2p.mDisconnectMutex.unlock ();
1315         }
1316         break;
1317 
1318     case NFA_P2P_DATA_EVT:
1319         // Look for the connection block
1320         if ((pConn = sP2p.findConnection(eventData->data.handle)) == NULL)
1321         {
1322             ALOGE ("%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->data.handle);
1323         }
1324         else
1325         {
1326             ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_DATA_EVT; h=0x%X; remote sap=0x%X", fn,
1327                     eventData->data.handle, eventData->data.remote_sap);
1328             SyncEventGuard guard (pConn->mReadEvent);
1329             pConn->mReadEvent.notifyOne();
1330         }
1331         break;
1332 
1333     case NFA_P2P_CONGEST_EVT:
1334         // Look for the connection block
1335         if ((pConn = sP2p.findConnection(eventData->congest.handle)) == NULL)
1336         {
1337             ALOGE ("%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->congest.handle);
1338         }
1339         else
1340         {
1341             ALOGD ("%s: NFA_P2P_CONGEST_EVT; nfa handle: 0x%04x  congested: %u", fn,
1342                     eventData->congest.handle, eventData->congest.is_congested);
1343             if (eventData->congest.is_congested == FALSE)
1344             {
1345                 SyncEventGuard guard (pConn->mCongEvent);
1346                 pConn->mCongEvent.notifyOne();
1347             }
1348         }
1349         break;
1350 
1351     default:
1352         ALOGE ("%s: unknown event 0x%X ????", fn, p2pEvent);
1353         break;
1354     }
1355     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit", fn);
1356 }
1357 
1358 
1359 /*******************************************************************************
1360 **
1361 ** Function:        nfaClientCallback
1362 **
1363 ** Description:     Receive LLCP-related events from the stack.
1364 **                  p2pEvent: Event code.
1365 **                  eventData: Event data.
1366 **
1367 ** Returns:         None
1368 **
1369 *******************************************************************************/
nfaClientCallback(tNFA_P2P_EVT p2pEvent,tNFA_P2P_EVT_DATA * eventData)1370 void PeerToPeer::nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* eventData)
1371 {
1372     static const char fn [] = "PeerToPeer::nfaClientCallback";
1373     sp<NfaConn>     pConn = NULL;
1374     sp<P2pClient>   pClient = NULL;
1375 
1376     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; event=%u", fn, p2pEvent);
1377 
1378     switch (p2pEvent)
1379     {
1380     case NFA_P2P_REG_CLIENT_EVT:
1381         // Look for a client that is trying to register
1382         if ((pClient = sP2p.findClient ((tNFA_HANDLE)NFA_HANDLE_INVALID)) == NULL)
1383         {
1384             ALOGE ("%s: NFA_P2P_REG_CLIENT_EVT: can't find waiting client", fn);
1385         }
1386         else
1387         {
1388             ALOGD ("%s: NFA_P2P_REG_CLIENT_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->reg_client.client_handle, pClient.get());
1389 
1390             SyncEventGuard guard (pClient->mRegisteringEvent);
1391             pClient->mNfaP2pClientHandle = eventData->reg_client.client_handle;
1392             pClient->mRegisteringEvent.notifyOne();
1393         }
1394         break;
1395 
1396     case NFA_P2P_ACTIVATED_EVT:
1397         // Look for a client that is trying to register
1398         if ((pClient = sP2p.findClient (eventData->activated.handle)) == NULL)
1399         {
1400             ALOGE ("%s: NFA_P2P_ACTIVATED_EVT: can't find client", fn);
1401         }
1402         else
1403         {
1404             ALOGD ("%s: NFA_P2P_ACTIVATED_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->activated.handle, pClient.get());
1405         }
1406         break;
1407 
1408     case NFA_P2P_DEACTIVATED_EVT:
1409         ALOGD ("%s: NFA_P2P_DEACTIVATED_EVT: conn handle: 0x%X", fn, eventData->deactivated.handle);
1410         break;
1411 
1412     case NFA_P2P_CONNECTED_EVT:
1413         // Look for the client that is trying to connect
1414         if ((pClient = sP2p.findClient (eventData->connected.client_handle)) == NULL)
1415         {
1416             ALOGE ("%s: NFA_P2P_CONNECTED_EVT: can't find client: 0x%04x", fn, eventData->connected.client_handle);
1417         }
1418         else
1419         {
1420             ALOGD ("%s: NFA_P2P_CONNECTED_EVT; client_handle=0x%04x  conn_handle: 0x%04x  remote sap=0x%X  pClient: 0x%p", fn,
1421                     eventData->connected.client_handle, eventData->connected.conn_handle, eventData->connected.remote_sap, pClient.get());
1422 
1423             SyncEventGuard guard (pClient->mConnectingEvent);
1424             pClient->mClientConn->mNfaConnHandle     = eventData->connected.conn_handle;
1425             pClient->mClientConn->mRemoteMaxInfoUnit = eventData->connected.remote_miu;
1426             pClient->mClientConn->mRemoteRecvWindow  = eventData->connected.remote_rw;
1427             pClient->mConnectingEvent.notifyOne(); //unblock createDataLinkConn()
1428         }
1429         break;
1430 
1431     case NFA_P2P_DISC_EVT:
1432         ALOGD ("%s: NFA_P2P_DISC_EVT; h=0x%04x; reason=0x%X", fn, eventData->disc.handle, eventData->disc.reason);
1433         // Look for the connection block
1434         if ((pConn = sP2p.findConnection(eventData->disc.handle)) == NULL)
1435         {
1436             // If no connection, may be a client that is trying to connect
1437             if ((pClient = sP2p.findClient (eventData->disc.handle)) == NULL)
1438             {
1439                 ALOGE ("%s: NFA_P2P_DISC_EVT: can't find client for NFA handle: 0x%04x", fn, eventData->disc.handle);
1440                 return;
1441             }
1442             // Unblock createDataLinkConn()
1443             SyncEventGuard guard (pClient->mConnectingEvent);
1444             pClient->mConnectingEvent.notifyOne();
1445         }
1446         else
1447         {
1448             sP2p.mDisconnectMutex.lock ();
1449             pConn->mNfaConnHandle = NFA_HANDLE_INVALID;
1450             {
1451                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard disconn event", fn);
1452                 SyncEventGuard guard3 (pConn->mDisconnectingEvent);
1453                 pConn->mDisconnectingEvent.notifyOne ();
1454                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified disconn event", fn);
1455             }
1456             {
1457                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard congest event", fn);
1458                 SyncEventGuard guard1 (pConn->mCongEvent);
1459                 pConn->mCongEvent.notifyOne(); //unblock write (if congested)
1460                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified congest event", fn);
1461             }
1462             {
1463                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard read event", fn);
1464                 SyncEventGuard guard2 (pConn->mReadEvent);
1465                 pConn->mReadEvent.notifyOne(); //unblock receive()
1466                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified read event", fn);
1467             }
1468             sP2p.mDisconnectMutex.unlock ();
1469         }
1470         break;
1471 
1472     case NFA_P2P_DATA_EVT:
1473         // Look for the connection block
1474         if ((pConn = sP2p.findConnection(eventData->data.handle)) == NULL)
1475         {
1476             ALOGE ("%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->data.handle);
1477         }
1478         else
1479         {
1480             ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_DATA_EVT; h=0x%X; remote sap=0x%X", fn,
1481                     eventData->data.handle, eventData->data.remote_sap);
1482             SyncEventGuard guard (pConn->mReadEvent);
1483             pConn->mReadEvent.notifyOne();
1484         }
1485         break;
1486 
1487     case NFA_P2P_CONGEST_EVT:
1488         // Look for the connection block
1489         if ((pConn = sP2p.findConnection(eventData->congest.handle)) == NULL)
1490         {
1491             ALOGE ("%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->congest.handle);
1492         }
1493         else
1494         {
1495             ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_CONGEST_EVT; nfa handle: 0x%04x  congested: %u", fn,
1496                     eventData->congest.handle, eventData->congest.is_congested);
1497 
1498             SyncEventGuard guard (pConn->mCongEvent);
1499             pConn->mCongEvent.notifyOne();
1500         }
1501         break;
1502 
1503     default:
1504         ALOGE ("%s: unknown event 0x%X ????", fn, p2pEvent);
1505         break;
1506     }
1507 }
1508 
1509 
1510 /*******************************************************************************
1511 **
1512 ** Function:        connectionEventHandler
1513 **
1514 ** Description:     Receive events from the stack.
1515 **                  event: Event code.
1516 **                  eventData: Event data.
1517 **
1518 ** Returns:         None
1519 **
1520 *******************************************************************************/
connectionEventHandler(UINT8 event,tNFA_CONN_EVT_DATA *)1521 void PeerToPeer::connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* /*eventData*/)
1522 {
1523     switch (event)
1524     {
1525     case NFA_SET_P2P_LISTEN_TECH_EVT:
1526         {
1527             SyncEventGuard guard (mSetTechEvent);
1528             mSetTechEvent.notifyOne(); //unblock NFA_SetP2pListenTech()
1529             break;
1530         }
1531     }
1532 }
1533 
1534 
1535 /*******************************************************************************
1536 **
1537 ** Function:        getNextJniHandle
1538 **
1539 ** Description:     Get a new JNI handle.
1540 **
1541 ** Returns:         A new JNI handle.
1542 **
1543 *******************************************************************************/
getNewJniHandle()1544 PeerToPeer::tJNI_HANDLE PeerToPeer::getNewJniHandle ()
1545 {
1546     tJNI_HANDLE newHandle = 0;
1547 
1548     mNewJniHandleMutex.lock ();
1549     newHandle = mNextJniHandle++;
1550     mNewJniHandleMutex.unlock ();
1551     return newHandle;
1552 }
1553 
1554 
1555 /////////////////////////////////////////////////////////////////////////
1556 /////////////////////////////////////////////////////////////////////////
1557 
1558 
1559 /*******************************************************************************
1560 **
1561 ** Function:        P2pServer
1562 **
1563 ** Description:     Initialize member variables.
1564 **
1565 ** Returns:         None
1566 **
1567 *******************************************************************************/
P2pServer(PeerToPeer::tJNI_HANDLE jniHandle,const char * serviceName)1568 P2pServer::P2pServer(PeerToPeer::tJNI_HANDLE jniHandle, const char* serviceName)
1569 :   mNfaP2pServerHandle (NFA_HANDLE_INVALID),
1570     mJniHandle (jniHandle)
1571 {
1572     mServiceName.assign (serviceName);
1573 
1574     memset (mServerConn, 0, sizeof(mServerConn));
1575 }
1576 
registerWithStack()1577 bool P2pServer::registerWithStack()
1578 {
1579     static const char fn [] = "P2pServer::registerWithStack";
1580     ALOGD ("%s: enter; service name: %s  JNI handle: %u", fn, mServiceName.c_str(), mJniHandle);
1581     tNFA_STATUS     stat  = NFA_STATUS_OK;
1582     UINT8           serverSap = NFA_P2P_ANY_SAP;
1583 
1584     /**********************
1585    default values for all LLCP parameters:
1586    - Local Link MIU (LLCP_MIU)
1587    - Option parameter (LLCP_OPT_VALUE)
1588    - Response Waiting Time Index (LLCP_WAITING_TIME)
1589    - Local Link Timeout (LLCP_LTO_VALUE)
1590    - Inactivity Timeout as initiator role (LLCP_INIT_INACTIVITY_TIMEOUT)
1591    - Inactivity Timeout as target role (LLCP_TARGET_INACTIVITY_TIMEOUT)
1592    - Delay SYMM response (LLCP_DELAY_RESP_TIME)
1593    - Data link connection timeout (LLCP_DATA_LINK_CONNECTION_TOUT)
1594    - Delay timeout to send first PDU as initiator (LLCP_DELAY_TIME_TO_SEND_FIRST_PDU)
1595    ************************/
1596    stat = NFA_P2pSetLLCPConfig (LLCP_MAX_MIU,
1597            LLCP_OPT_VALUE,
1598            LLCP_WAITING_TIME,
1599            LLCP_LTO_VALUE,
1600            0, //use 0 for infinite timeout for symmetry procedure when acting as initiator
1601            0, //use 0 for infinite timeout for symmetry procedure when acting as target
1602            LLCP_DELAY_RESP_TIME,
1603            LLCP_DATA_LINK_TIMEOUT,
1604            LLCP_DELAY_TIME_TO_SEND_FIRST_PDU);
1605    if (stat != NFA_STATUS_OK)
1606        ALOGE ("%s: fail set LLCP config; error=0x%X", fn, stat);
1607 
1608    if (sSnepServiceName.compare(mServiceName) == 0)
1609        serverSap = LLCP_SAP_SNEP; //LLCP_SAP_SNEP == 4
1610 
1611    {
1612        SyncEventGuard guard (mRegServerEvent);
1613        stat = NFA_P2pRegisterServer (serverSap, NFA_P2P_DLINK_TYPE, const_cast<char*>(mServiceName.c_str()),
1614                PeerToPeer::nfaServerCallback);
1615        if (stat != NFA_STATUS_OK)
1616        {
1617            ALOGE ("%s: fail register p2p server; error=0x%X", fn, stat);
1618            return (false);
1619        }
1620        ALOGD ("%s: wait for listen-completion event", fn);
1621        // Wait for NFA_P2P_REG_SERVER_EVT
1622        mRegServerEvent.wait ();
1623    }
1624 
1625    return (mNfaP2pServerHandle != NFA_HANDLE_INVALID);
1626 }
1627 
accept(PeerToPeer::tJNI_HANDLE serverJniHandle,PeerToPeer::tJNI_HANDLE connJniHandle,int maxInfoUnit,int recvWindow)1628 bool P2pServer::accept(PeerToPeer::tJNI_HANDLE serverJniHandle, PeerToPeer::tJNI_HANDLE connJniHandle,
1629         int maxInfoUnit, int recvWindow)
1630 {
1631     static const char fn [] = "P2pServer::accept";
1632     tNFA_STATUS     nfaStat  = NFA_STATUS_OK;
1633 
1634     sp<NfaConn> connection = allocateConnection(connJniHandle);
1635     if (connection == NULL) {
1636         ALOGE ("%s: failed to allocate new server connection", fn);
1637         return false;
1638     }
1639 
1640     {
1641         // Wait for NFA_P2P_CONN_REQ_EVT or NFA_NDEF_DATA_EVT when remote device requests connection
1642         SyncEventGuard guard (mConnRequestEvent);
1643         ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; wait for incoming connection", fn,
1644                 serverJniHandle, connJniHandle);
1645         mConnRequestEvent.wait();
1646         ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; got incoming connection", fn,
1647                 serverJniHandle, connJniHandle, connection->mNfaConnHandle);
1648     }
1649 
1650     if (connection->mNfaConnHandle == NFA_HANDLE_INVALID)
1651     {
1652         removeServerConnection(connJniHandle);
1653         ALOGD ("%s: no handle assigned", fn);
1654         return (false);
1655     }
1656 
1657     ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; try accept", fn,
1658             serverJniHandle, connJniHandle, connection->mNfaConnHandle);
1659     nfaStat = NFA_P2pAcceptConn (connection->mNfaConnHandle, maxInfoUnit, recvWindow);
1660 
1661     if (nfaStat != NFA_STATUS_OK)
1662     {
1663         ALOGE ("%s: fail to accept remote; error=0x%X", fn, nfaStat);
1664         return (false);
1665     }
1666 
1667     ALOGD ("%s: exit; serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X", fn,
1668             serverJniHandle, connJniHandle, connection->mNfaConnHandle);
1669     return (true);
1670 }
1671 
unblockAll()1672 void P2pServer::unblockAll()
1673 {
1674     AutoMutex mutex(mMutex);
1675     for (int jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
1676     {
1677         if (mServerConn[jj] != NULL)
1678         {
1679             mServerConn[jj]->mNfaConnHandle = NFA_HANDLE_INVALID;
1680             {
1681                 SyncEventGuard guard1 (mServerConn[jj]->mCongEvent);
1682                 mServerConn[jj]->mCongEvent.notifyOne (); //unblock write (if congested)
1683             }
1684             {
1685                 SyncEventGuard guard2 (mServerConn[jj]->mReadEvent);
1686                 mServerConn[jj]->mReadEvent.notifyOne (); //unblock receive()
1687             }
1688         }
1689     }
1690 }
1691 
allocateConnection(PeerToPeer::tJNI_HANDLE jniHandle)1692 sp<NfaConn> P2pServer::allocateConnection (PeerToPeer::tJNI_HANDLE jniHandle)
1693 {
1694     AutoMutex mutex(mMutex);
1695     // First, find a free connection block to handle the connection
1696     for (int ii = 0; ii < MAX_NFA_CONNS_PER_SERVER; ii++)
1697     {
1698         if (mServerConn[ii] == NULL)
1699         {
1700             mServerConn[ii] = new NfaConn;
1701             mServerConn[ii]->mJniHandle = jniHandle;
1702             return mServerConn[ii];
1703         }
1704     }
1705 
1706     return NULL;
1707 }
1708 
1709 
1710 /*******************************************************************************
1711 **
1712 ** Function:        findServerConnection
1713 **
1714 ** Description:     Find a P2pServer that has the handle.
1715 **                  nfaConnHandle: NFA connection handle.
1716 **
1717 ** Returns:         P2pServer object.
1718 **
1719 *******************************************************************************/
findServerConnection(tNFA_HANDLE nfaConnHandle)1720 sp<NfaConn> P2pServer::findServerConnection (tNFA_HANDLE nfaConnHandle)
1721 {
1722     int jj = 0;
1723 
1724     AutoMutex mutex(mMutex);
1725     for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
1726     {
1727         if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mNfaConnHandle == nfaConnHandle) )
1728             return (mServerConn[jj]);
1729     }
1730 
1731     // If here, not found
1732     return (NULL);
1733 }
1734 
1735 /*******************************************************************************
1736 **
1737 ** Function:        findServerConnection
1738 **
1739 ** Description:     Find a P2pServer that has the handle.
1740 **                  nfaConnHandle: NFA connection handle.
1741 **
1742 ** Returns:         P2pServer object.
1743 **
1744 *******************************************************************************/
findServerConnection(PeerToPeer::tJNI_HANDLE jniHandle)1745 sp<NfaConn> P2pServer::findServerConnection (PeerToPeer::tJNI_HANDLE jniHandle)
1746 {
1747     int jj = 0;
1748 
1749     AutoMutex mutex(mMutex);
1750     for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
1751     {
1752         if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) )
1753             return (mServerConn[jj]);
1754     }
1755 
1756     // If here, not found
1757     return (NULL);
1758 }
1759 
1760 /*******************************************************************************
1761 **
1762 ** Function:        removeServerConnection
1763 **
1764 ** Description:     Find a P2pServer that has the handle.
1765 **                  nfaConnHandle: NFA connection handle.
1766 **
1767 ** Returns:         P2pServer object.
1768 **
1769 *******************************************************************************/
removeServerConnection(PeerToPeer::tJNI_HANDLE jniHandle)1770 bool P2pServer::removeServerConnection (PeerToPeer::tJNI_HANDLE jniHandle)
1771 {
1772     int jj = 0;
1773 
1774     AutoMutex mutex(mMutex);
1775     for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
1776     {
1777         if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) ) {
1778             mServerConn[jj] = NULL;
1779             return true;
1780         }
1781     }
1782 
1783     // If here, not found
1784     return false;
1785 }
1786 /////////////////////////////////////////////////////////////////////////
1787 /////////////////////////////////////////////////////////////////////////
1788 
1789 
1790 /*******************************************************************************
1791 **
1792 ** Function:        P2pClient
1793 **
1794 ** Description:     Initialize member variables.
1795 **
1796 ** Returns:         None
1797 **
1798 *******************************************************************************/
P2pClient()1799 P2pClient::P2pClient ()
1800 :   mNfaP2pClientHandle (NFA_HANDLE_INVALID),
1801     mIsConnecting (false)
1802 {
1803     mClientConn = new NfaConn();
1804 }
1805 
1806 
1807 /*******************************************************************************
1808 **
1809 ** Function:        ~P2pClient
1810 **
1811 ** Description:     Free all resources.
1812 **
1813 ** Returns:         None
1814 **
1815 *******************************************************************************/
~P2pClient()1816 P2pClient::~P2pClient ()
1817 {
1818 }
1819 
1820 
1821 /////////////////////////////////////////////////////////////////////////
1822 /////////////////////////////////////////////////////////////////////////
1823 
1824 
1825 /*******************************************************************************
1826 **
1827 ** Function:        NfaConn
1828 **
1829 ** Description:     Initialize member variables.
1830 **
1831 ** Returns:         None
1832 **
1833 *******************************************************************************/
NfaConn()1834 NfaConn::NfaConn()
1835 :   mNfaConnHandle (NFA_HANDLE_INVALID),
1836     mJniHandle (0),
1837     mMaxInfoUnit (0),
1838     mRecvWindow (0),
1839     mRemoteMaxInfoUnit (0),
1840     mRemoteRecvWindow (0)
1841 {
1842 }
1843