• 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 #pragma once
21 #include <utils/RefBase.h>
22 #include <utils/StrongPointer.h>
23 #include <string>
24 #include "NfcJniUtil.h"
25 #include "SyncEvent.h"
26 #include "nfa_p2p_api.h"
27 
28 class P2pServer;
29 class P2pClient;
30 class NfaConn;
31 #define MAX_NFA_CONNS_PER_SERVER 5
32 
33 /*****************************************************************************
34 **
35 **  Name:           PeerToPeer
36 **
37 **  Description:    Communicate with a peer using NFC-DEP, LLCP, SNEP.
38 **
39 *****************************************************************************/
40 class PeerToPeer {
41  public:
42   typedef unsigned int tJNI_HANDLE;
43 
44   /*******************************************************************************
45   **
46   ** Function:        PeerToPeer
47   **
48   ** Description:     Initialize member variables.
49   **
50   ** Returns:         None
51   **
52   *******************************************************************************/
53   PeerToPeer();
54 
55   /*******************************************************************************
56   **
57   ** Function:        ~PeerToPeer
58   **
59   ** Description:     Free all resources.
60   **
61   ** Returns:         None
62   **
63   *******************************************************************************/
64   ~PeerToPeer();
65 
66   /*******************************************************************************
67   **
68   ** Function:        getInstance
69   **
70   ** Description:     Get the singleton PeerToPeer object.
71   **
72   ** Returns:         Singleton PeerToPeer object.
73   **
74   *******************************************************************************/
75   static PeerToPeer& getInstance();
76 
77   /*******************************************************************************
78   **
79   ** Function:        initialize
80   **
81   ** Description:     Initialize member variables.
82   **
83   ** Returns:         None
84   **
85   *******************************************************************************/
86   void initialize();
87 
88   /*******************************************************************************
89   **
90   ** Function:        llcpActivatedHandler
91   **
92   ** Description:     Receive LLLCP-activated event from stack.
93   **                  nat: JVM-related data.
94   **                  activated: Event data.
95   **
96   ** Returns:         None
97   **
98   *******************************************************************************/
99   void llcpActivatedHandler(nfc_jni_native_data* nativeData,
100                             tNFA_LLCP_ACTIVATED& activated);
101 
102   /*******************************************************************************
103   **
104   ** Function:        llcpDeactivatedHandler
105   **
106   ** Description:     Receive LLLCP-deactivated event from stack.
107   **                  nat: JVM-related data.
108   **                  deactivated: Event data.
109   **
110   ** Returns:         None
111   **
112   *******************************************************************************/
113   void llcpDeactivatedHandler(nfc_jni_native_data* nativeData,
114                               tNFA_LLCP_DEACTIVATED& deactivated);
115 
116   void llcpFirstPacketHandler(nfc_jni_native_data* nativeData);
117 
118   /*******************************************************************************
119   **
120   ** Function:        connectionEventHandler
121   **
122   ** Description:     Receive events from the stack.
123   **                  event: Event code.
124   **                  eventData: Event data.
125   **
126   ** Returns:         None
127   **
128   *******************************************************************************/
129   void connectionEventHandler(uint8_t event, tNFA_CONN_EVT_DATA* eventData);
130 
131   /*******************************************************************************
132   **
133   ** Function:        registerServer
134   **
135   ** Description:     Let a server start listening for peer's connection
136   *request.
137   **                  jniHandle: Connection handle.
138   **                  serviceName: Server's service name.
139   **
140   ** Returns:         True if ok.
141   **
142   *******************************************************************************/
143   bool registerServer(tJNI_HANDLE jniHandle, const char* serviceName);
144 
145   /*******************************************************************************
146   **
147   ** Function:        deregisterServer
148   **
149   ** Description:     Stop a P2pServer from listening for peer.
150   **
151   ** Returns:         True if ok.
152   **
153   *******************************************************************************/
154   bool deregisterServer(tJNI_HANDLE jniHandle);
155 
156   /*******************************************************************************
157   **
158   ** Function:        accept
159   **
160   ** Description:     Accept a peer's request to connect.
161   **                  serverJniHandle: Server's handle.
162   **                  connJniHandle: Connection handle.
163   **                  maxInfoUnit: Maximum information unit.
164   **                  recvWindow: Receive window size.
165   **
166   ** Returns:         True if ok.
167   **
168   *******************************************************************************/
169   bool accept(tJNI_HANDLE serverJniHandle, tJNI_HANDLE connJniHandle,
170               int maxInfoUnit, int recvWindow);
171 
172   /*******************************************************************************
173   **
174   ** Function:        createClient
175   **
176   ** Description:     Create a P2pClient object for a new out-bound connection.
177   **                  jniHandle: Connection handle.
178   **                  miu: Maximum information unit.
179   **                  rw: Receive window size.
180   **
181   ** Returns:         True if ok.
182   **
183   *******************************************************************************/
184   bool createClient(tJNI_HANDLE jniHandle, uint16_t miu, uint8_t rw);
185 
186   /*******************************************************************************
187   **
188   ** Function:        connectConnOriented
189   **
190   ** Description:     Establish a connection-oriented connection to a peer.
191   **                  jniHandle: Connection handle.
192   **                  serviceName: Peer's service name.
193   **
194   ** Returns:         True if ok.
195   **
196   *******************************************************************************/
197   bool connectConnOriented(tJNI_HANDLE jniHandle, const char* serviceName);
198 
199   /*******************************************************************************
200   **
201   ** Function:        connectConnOriented
202   **
203   ** Description:     Establish a connection-oriented connection to a peer.
204   **                  jniHandle: Connection handle.
205   **                  destinationSap: Peer's service access point.
206   **
207   ** Returns:         True if ok.
208   **
209   *******************************************************************************/
210   bool connectConnOriented(tJNI_HANDLE jniHandle, uint8_t destinationSap);
211 
212   /*******************************************************************************
213   **
214   ** Function:        send
215   **
216   ** Description:     Send data to peer.
217   **                  jniHandle: Handle of connection.
218   **                  buffer: Buffer of data.
219   **                  bufferLen: Length of data.
220   **
221   ** Returns:         True if ok.
222   **
223   *******************************************************************************/
224   bool send(tJNI_HANDLE jniHandle, uint8_t* buffer, uint16_t bufferLen);
225 
226   /*******************************************************************************
227   **
228   ** Function:        receive
229   **
230   ** Description:     Receive data from peer.
231   **                  jniHandle: Handle of connection.
232   **                  buffer: Buffer to store data.
233   **                  bufferLen: Max length of buffer.
234   **                  actualLen: Actual length received.
235   **
236   ** Returns:         True if ok.
237   **
238   *******************************************************************************/
239   bool receive(tJNI_HANDLE jniHandle, uint8_t* buffer, uint16_t bufferLen,
240                uint16_t& actualLen);
241 
242   /*******************************************************************************
243   **
244   ** Function:        disconnectConnOriented
245   **
246   ** Description:     Disconnect a connection-oriented connection with peer.
247   **                  jniHandle: Handle of connection.
248   **
249   ** Returns:         True if ok.
250   **
251   *******************************************************************************/
252   bool disconnectConnOriented(tJNI_HANDLE jniHandle);
253 
254   /*******************************************************************************
255   **
256   ** Function:        getRemoteMaxInfoUnit
257   **
258   ** Description:     Get peer's max information unit.
259   **                  jniHandle: Handle of the connection.
260   **
261   ** Returns:         Peer's max information unit.
262   **
263   *******************************************************************************/
264   uint16_t getRemoteMaxInfoUnit(tJNI_HANDLE jniHandle);
265 
266   /*******************************************************************************
267   **
268   ** Function:        getRemoteRecvWindow
269   **
270   ** Description:     Get peer's receive window size.
271   **                  jniHandle: Handle of the connection.
272   **
273   ** Returns:         Peer's receive window size.
274   **
275   *******************************************************************************/
276   uint8_t getRemoteRecvWindow(tJNI_HANDLE jniHandle);
277 
278   /*******************************************************************************
279   **
280   ** Function:        setP2pListenMask
281   **
282   ** Description:     Sets the p2p listen technology mask.
283   **                  p2pListenMask: the p2p listen mask to be set?
284   **
285   ** Returns:         None
286   **
287   *******************************************************************************/
288   void setP2pListenMask(tNFA_TECHNOLOGY_MASK p2pListenMask);
289 
290   /*******************************************************************************
291   **
292   ** Function:        getP2pListenMask
293   **
294   ** Description:     Get the set of technologies that P2P is listening.
295   **
296   ** Returns:         Set of technologies.
297   **
298   *******************************************************************************/
299   tNFA_TECHNOLOGY_MASK getP2pListenMask();
300 
301   /*******************************************************************************
302   **
303   ** Function:        resetP2pListenMask
304   **
305   ** Description:     Reset the p2p listen technology mask to initial value.
306   **
307   ** Returns:         None.
308   **
309   *******************************************************************************/
310   void resetP2pListenMask();
311 
312   /*******************************************************************************
313   **
314   ** Function:        enableP2pListening
315   **
316   ** Description:     Start/stop polling/listening to peer that supports P2P.
317   **                  isEnable: Is enable polling/listening?
318   **
319   ** Returns:         None
320   **
321   *******************************************************************************/
322   void enableP2pListening(bool isEnable);
323 
324   /*******************************************************************************
325   **
326   ** Function:        handleNfcOnOff
327   **
328   ** Description:     Handle events related to turning NFC on/off by the user.
329   **                  isOn: Is NFC turning on?
330   **
331   ** Returns:         None
332   **
333   *******************************************************************************/
334   void handleNfcOnOff(bool isOn);
335 
336   /*******************************************************************************
337   **
338   ** Function:        getNextJniHandle
339   **
340   ** Description:     Get a new JNI handle.
341   **
342   ** Returns:         A new JNI handle.
343   **
344   *******************************************************************************/
345   tJNI_HANDLE getNewJniHandle();
346 
347   /*******************************************************************************
348   **
349   ** Function:        nfaServerCallback
350   **
351   ** Description:     Receive LLCP-related events from the stack.
352   **                  p2pEvent: Event code.
353   **                  eventData: Event data.
354   **
355   ** Returns:         None
356   **
357   *******************************************************************************/
358   static void nfaServerCallback(tNFA_P2P_EVT p2pEvent,
359                                 tNFA_P2P_EVT_DATA* eventData);
360 
361   /*******************************************************************************
362   **
363   ** Function:        nfaClientCallback
364   **
365   ** Description:     Receive LLCP-related events from the stack.
366   **                  p2pEvent: Event code.
367   **                  eventData: Event data.
368   **
369   ** Returns:         None
370   **
371   *******************************************************************************/
372   static void nfaClientCallback(tNFA_P2P_EVT p2pEvent,
373                                 tNFA_P2P_EVT_DATA* eventData);
374 
375  private:
376   static const int sMax = 10;
377   static PeerToPeer sP2p;
378 
379   // Variables below only accessed from a single thread
380   uint16_t mRemoteWKS;   // Peer's well known services
381   bool mIsP2pListening;  // If P2P listening is enabled or not
382   tNFA_TECHNOLOGY_MASK mP2pListenTechMask;  // P2P Listen mask
383 
384   // Variable below is protected by mNewJniHandleMutex
385   tJNI_HANDLE mNextJniHandle;
386 
387   // Variables below protected by mMutex
388   // A note on locking order: mMutex in PeerToPeer is *ALWAYS*
389   // locked before any locks / guards in P2pServer / P2pClient
390   Mutex mMutex;
391   android::sp<P2pServer> mServers[sMax];
392   android::sp<P2pClient> mClients[sMax];
393 
394   // Synchronization variables
395   SyncEvent mSetTechEvent;  // completion event for NFA_SetP2pListenTech()
396   SyncEvent mSnepDefaultServerStartStopEvent;  // completion event for
397                                                // NFA_SnepStartDefaultServer(),
398                                                // NFA_SnepStopDefaultServer()
399   SyncEvent
400       mSnepRegisterEvent;    // completion event for NFA_SnepRegisterClient()
401   Mutex mDisconnectMutex;    // synchronize the disconnect operation
402   Mutex mNewJniHandleMutex;  // synchronize the creation of a new JNI handle
403 
404   /*******************************************************************************
405   **
406   ** Function:        ndefTypeCallback
407   **
408   ** Description:     Receive NDEF-related events from the stack.
409   **                  ndefEvent: Event code.
410   **                  eventData: Event data.
411   **
412   ** Returns:         None
413   **
414   *******************************************************************************/
415   static void ndefTypeCallback(tNFA_NDEF_EVT event,
416                                tNFA_NDEF_EVT_DATA* evetnData);
417 
418   /*******************************************************************************
419   **
420   ** Function:        findServer
421   **
422   ** Description:     Find a PeerToPeer object by connection handle.
423   **                  nfaP2pServerHandle: Connectin handle.
424   **
425   ** Returns:         PeerToPeer object.
426   **
427   *******************************************************************************/
428   android::sp<P2pServer> findServerLocked(tNFA_HANDLE nfaP2pServerHandle);
429 
430   /*******************************************************************************
431   **
432   ** Function:        findServer
433   **
434   ** Description:     Find a PeerToPeer object by connection handle.
435   **                  serviceName: service name.
436   **
437   ** Returns:         PeerToPeer object.
438   **
439   *******************************************************************************/
440   android::sp<P2pServer> findServerLocked(tJNI_HANDLE jniHandle);
441 
442   /*******************************************************************************
443   **
444   ** Function:        findServer
445   **
446   ** Description:     Find a PeerToPeer object by service name
447   **                  serviceName: service name.
448   **
449   ** Returns:         PeerToPeer object.
450   **
451   *******************************************************************************/
452   android::sp<P2pServer> findServerLocked(const char* serviceName);
453 
454   /*******************************************************************************
455   **
456   ** Function:        removeServer
457   **
458   ** Description:     Free resources related to a server.
459   **                  jniHandle: Connection handle.
460   **
461   ** Returns:         None
462   **
463   *******************************************************************************/
464   void removeServer(tJNI_HANDLE jniHandle);
465 
466   /*******************************************************************************
467   **
468   ** Function:        removeConn
469   **
470   ** Description:     Free resources related to a connection.
471   **                  jniHandle: Connection handle.
472   **
473   ** Returns:         None
474   **
475   *******************************************************************************/
476   void removeConn(tJNI_HANDLE jniHandle);
477 
478   /*******************************************************************************
479   **
480   ** Function:        createDataLinkConn
481   **
482   ** Description:     Establish a connection-oriented connection to a peer.
483   **                  jniHandle: Connection handle.
484   **                  serviceName: Peer's service name.
485   **                  destinationSap: Peer's service access point.
486   **
487   ** Returns:         True if ok.
488   **
489   *******************************************************************************/
490   bool createDataLinkConn(tJNI_HANDLE jniHandle, const char* serviceName,
491                           uint8_t destinationSap);
492 
493   /*******************************************************************************
494   **
495   ** Function:        findClient
496   **
497   ** Description:     Find a PeerToPeer object with a client connection handle.
498   **                  nfaConnHandle: Connection handle.
499   **
500   ** Returns:         PeerToPeer object.
501   **
502   *******************************************************************************/
503   android::sp<P2pClient> findClient(tNFA_HANDLE nfaConnHandle);
504 
505   /*******************************************************************************
506   **
507   ** Function:        findClient
508   **
509   ** Description:     Find a PeerToPeer object with a client connection handle.
510   **                  jniHandle: Connection handle.
511   **
512   ** Returns:         PeerToPeer object.
513   **
514   *******************************************************************************/
515   android::sp<P2pClient> findClient(tJNI_HANDLE jniHandle);
516 
517   /*******************************************************************************
518   **
519   ** Function:        findClientCon
520   **
521   ** Description:     Find a PeerToPeer object with a client connection handle.
522   **                  nfaConnHandle: Connection handle.
523   **
524   ** Returns:         PeerToPeer object.
525   **
526   *******************************************************************************/
527   android::sp<P2pClient> findClientCon(tNFA_HANDLE nfaConnHandle);
528 
529   /*******************************************************************************
530   **
531   ** Function:        findConnection
532   **
533   ** Description:     Find a PeerToPeer object with a connection handle.
534   **                  nfaConnHandle: Connection handle.
535   **
536   ** Returns:         PeerToPeer object.
537   **
538   *******************************************************************************/
539   android::sp<NfaConn> findConnection(tNFA_HANDLE nfaConnHandle);
540 
541   /*******************************************************************************
542   **
543   ** Function:        findConnection
544   **
545   ** Description:     Find a PeerToPeer object with a connection handle.
546   **                  jniHandle: Connection handle.
547   **
548   ** Returns:         PeerToPeer object.
549   **
550   *******************************************************************************/
551   android::sp<NfaConn> findConnection(tJNI_HANDLE jniHandle);
552 };
553 
554 /*****************************************************************************
555 **
556 **  Name:           NfaConn
557 **
558 **  Description:    Store information about a connection related to a peer.
559 **
560 *****************************************************************************/
561 class NfaConn : public android::RefBase {
562  public:
563   tNFA_HANDLE mNfaConnHandle;          // NFA handle of the P2P connection
564   PeerToPeer::tJNI_HANDLE mJniHandle;  // JNI handle of the P2P connection
565   uint16_t mMaxInfoUnit;
566   uint8_t mRecvWindow;
567   uint16_t mRemoteMaxInfoUnit;
568   uint8_t mRemoteRecvWindow;
569   SyncEvent mReadEvent;           // event for reading
570   SyncEvent mCongEvent;           // event for congestion
571   SyncEvent mDisconnectingEvent;  // event for disconnecting
572 
573   /*******************************************************************************
574   **
575   ** Function:        NfaConn
576   **
577   ** Description:     Initialize member variables.
578   **
579   ** Returns:         None
580   **
581   *******************************************************************************/
582   NfaConn();
583 };
584 
585 /*****************************************************************************
586 **
587 **  Name:           P2pServer
588 **
589 **  Description:    Store information about an in-bound connection from a peer.
590 **
591 *****************************************************************************/
592 class P2pServer : public android::RefBase {
593  public:
594   static const std::string sSnepServiceName;
595 
596   tNFA_HANDLE mNfaP2pServerHandle;     // NFA p2p handle of local server
597   PeerToPeer::tJNI_HANDLE mJniHandle;  // JNI Handle
598   SyncEvent mRegServerEvent;           // for NFA_P2pRegisterServer()
599   SyncEvent mConnRequestEvent;         // for accept()
600   std::string mServiceName;
601 
602   /*******************************************************************************
603   **
604   ** Function:        P2pServer
605   **
606   ** Description:     Initialize member variables.
607   **
608   ** Returns:         None
609   **
610   *******************************************************************************/
611   P2pServer(PeerToPeer::tJNI_HANDLE jniHandle, const char* serviceName);
612 
613   /*******************************************************************************
614   **
615   ** Function:        registerWithStack
616   **
617   ** Description:     Register this server with the stack.
618   **
619   ** Returns:         True if ok.
620   **
621   *******************************************************************************/
622   bool registerWithStack();
623 
624   /*******************************************************************************
625   **
626   ** Function:        accept
627   **
628   ** Description:     Accept a peer's request to connect.
629   **                  serverJniHandle: Server's handle.
630   **                  connJniHandle: Connection handle.
631   **                  maxInfoUnit: Maximum information unit.
632   **                  recvWindow: Receive window size.
633   **
634   ** Returns:         True if ok.
635   **
636   *******************************************************************************/
637   bool accept(PeerToPeer::tJNI_HANDLE serverJniHandle,
638               PeerToPeer::tJNI_HANDLE connJniHandle, int maxInfoUnit,
639               int recvWindow);
640 
641   /*******************************************************************************
642   **
643   ** Function:        unblockAll
644   **
645   ** Description:     Unblocks all server connections
646   **
647   ** Returns:         True if ok.
648   **
649   *******************************************************************************/
650   void unblockAll();
651 
652   /*******************************************************************************
653   **
654   ** Function:        findServerConnection
655   **
656   ** Description:     Find a P2pServer that has the handle.
657   **                  nfaConnHandle: NFA connection handle.
658   **
659   ** Returns:         P2pServer object.
660   **
661   *******************************************************************************/
662   android::sp<NfaConn> findServerConnection(tNFA_HANDLE nfaConnHandle);
663 
664   /*******************************************************************************
665   **
666   ** Function:        findServerConnection
667   **
668   ** Description:     Find a P2pServer that has the handle.
669   **                  jniHandle: JNI connection handle.
670   **
671   ** Returns:         P2pServer object.
672   **
673   *******************************************************************************/
674   android::sp<NfaConn> findServerConnection(PeerToPeer::tJNI_HANDLE jniHandle);
675 
676   /*******************************************************************************
677   **
678   ** Function:        removeServerConnection
679   **
680   ** Description:     Remove a server connection with the provided handle.
681   **                  jniHandle: JNI connection handle.
682   **
683   ** Returns:         True if connection found and removed.
684   **
685   *******************************************************************************/
686   bool removeServerConnection(PeerToPeer::tJNI_HANDLE jniHandle);
687 
688  private:
689   Mutex mMutex;
690   // mServerConn is protected by mMutex
691   android::sp<NfaConn> mServerConn[MAX_NFA_CONNS_PER_SERVER];
692 
693   /*******************************************************************************
694   **
695   ** Function:        allocateConnection
696   **
697   ** Description:     Allocate a new connection to accept on
698   **                  jniHandle: JNI connection handle.
699   **
700   ** Returns:         Allocated connection object
701   **                  NULL if the maximum number of connections was reached
702   **
703   *******************************************************************************/
704   android::sp<NfaConn> allocateConnection(PeerToPeer::tJNI_HANDLE jniHandle);
705 };
706 
707 /*****************************************************************************
708 **
709 **  Name:           P2pClient
710 **
711 **  Description:    Store information about an out-bound connection to a peer.
712 **
713 *****************************************************************************/
714 class P2pClient : public android::RefBase {
715  public:
716   tNFA_HANDLE mNfaP2pClientHandle;  // NFA p2p handle of client
717   bool mIsConnecting;               // Set true while connecting
718   android::sp<NfaConn> mClientConn;
719   SyncEvent mRegisteringEvent;  // For client registration
720   SyncEvent mConnectingEvent;   // for NFA_P2pConnectByName or Sap()
721   SyncEvent mSnepEvent;         // To wait for SNEP completion
722 
723   /*******************************************************************************
724   **
725   ** Function:        P2pClient
726   **
727   ** Description:     Initialize member variables.
728   **
729   ** Returns:         None
730   **
731   *******************************************************************************/
732   P2pClient();
733 
734   /*******************************************************************************
735   **
736   ** Function:        ~P2pClient
737   **
738   ** Description:     Free all resources.
739   **
740   ** Returns:         None
741   **
742   *******************************************************************************/
743   ~P2pClient();
744 
745   /*******************************************************************************
746   **
747   ** Function:        unblock
748   **
749   ** Description:     Unblocks any threads that are locked on this connection
750   **
751   ** Returns:         None
752   **
753   *******************************************************************************/
754   void unblock();
755 };
756