connectivitylayer/isce/isirouter_dll/inc/isicltransceiver.h
changeset 9 8486d82aef45
parent 7 fa67e03b87df
equal deleted inserted replaced
8:6295dc2169f3 9:8486d82aef45
    16 */
    16 */
    17 
    17 
    18 #ifndef __ISICLTRANSCEIVER_H__
    18 #ifndef __ISICLTRANSCEIVER_H__
    19 #define __ISICLTRANSCEIVER_H__
    19 #define __ISICLTRANSCEIVER_H__
    20 
    20 
    21 #include "misilinkrouterif.h"     // For MISILinkRouterIf
    21 #include "misilinkrouterif.h"           // For MISILinkRouterIf
    22 #include "isiinternaldefs.h"      // For KMaxNumOfObjId
    22 #include "isiinternaldefs.h"            // For KMaxNumOfObjId
    23 
    23 #include "misirouterservicerouterif.h"  // For MISIRouterServiceRouterIf
    24 
    24 
    25 class MISIRouterLinkIf;
    25 class MISIRouterLinkIf;
    26 class DISIRouter;
    26 class DISIRouter;
       
    27 class DIsiRouterService;
       
    28 class DISIMsgQueue;
    27 
    29 
    28 NONSHARABLE_CLASS( DISICLTransceiver ) : public DBase, public MISILinkRouterIf
    30 NONSHARABLE_CLASS( DISICLTransceiver ) : public DBase, public MISILinkRouterIf, public MISIRouterServiceRouterIf
    29     {
    31     {
    30 
    32 
    31     public:
    33     public:
    32 
    34 
    33         DISICLTransceiver( DISIRouter* aPtr );
    35         DISICLTransceiver( DISIRouter& aRouter, TDfcQue* aThreadPtr );
    34 
    36 
    35         ~DISICLTransceiver();
    37         ~DISICLTransceiver();
    36 
    38 
       
    39         // See comments from MISILinkRouterIf
       
    40         TInt RouteISIMessage( TDes8& aMessage, TBool aDynamicSenderCheckNeeded = ETrue );
       
    41         
       
    42         void ReceiveISIMessage( const TDesC8& aMessage, const TUint8 aTrxId );
       
    43 
       
    44         // See comments from MISILinkRouterIf
       
    45         void StateChanged();
       
    46 
       
    47         // From MISIRouterServiceRouterIf
       
    48         void GetDeviceConnectionStates( RArray<TUint8>& aDeviceIdentifierList, const TBool aConnectedDevice );
       
    49 
       
    50     private:
       
    51 
       
    52         static void StateChangedDfc( TAny* aPtr );
       
    53         
       
    54         static void RxQueueDfc( TAny* aPtr );
       
    55 
    37         TInt ValidateISIMessage( TDes8& aMessage );
    56         TInt ValidateISIMessage( TDes8& aMessage );
    38 
    57 
    39         TInt SendCommIsaEntityNotReachableResp( TDes8& aMessage );
    58         void ReadStateChanges();
    40 
    59 
    41         TUint8 MapDeviceToMedia( const TUint8 aDevice );
    60         // Responsibility to deallocate the message is transferred.
       
    61         TInt SendCommIsaEntityNotReachableResp( TDes8& aNotDeliveredMessage );
       
    62         
       
    63         TBool DynamicDevice( const TUint8 aDevId );
       
    64         
       
    65         void UpdateDynamicDeviceTable( const TUint8 aDynamicDevId, const TUint8 aStaticDevId );
       
    66         
       
    67         void DynamicToStaticDevice( TUint8& aRxDev );
    42 
    68 
    43         //From MISILinkRouterIf
    69         NONSHARABLE_CLASS( DISIDevice ) : public DBase
    44         TInt RouteISIMessage( TDes8& aMessage );
    70             {
       
    71             public:
    45 
    72 
    46     private:
    73                 DISIDevice( const TUint8 aDeviceIdentifier, MISIRouterLinkIf* aLink );
    47     
    74                 ~DISIDevice();
    48         //From objectapi
    75 
    49         TInt Send( TDes8& aMessage, const TUint8 aObjId );
    76                 MISIRouterLinkIf* GetLink();
    50     
    77                 TUint8 GetDeviceIdentifier();
    51         enum TISIMedias
    78                 TBool GetDeviceState();
       
    79                 TBool GetDeviceOldState();
       
    80                 void SetDeviceOldState( TBool aConnected );
       
    81                 // Shall be called before accessing operations.
       
    82                 void LockDeviceFM();
       
    83                 // Shall be called after accessing operations.
       
    84                 void FreeDeviceFM();
       
    85 
       
    86             private:
       
    87 
       
    88                 // Owned, synch internally
       
    89                 NFastMutex*                 iShDeviceMutex;
       
    90                 // Not owned, synch by above mutex.
       
    91                 MISIRouterLinkIf*   iShLink;
       
    92                 // Synch by above mutex.
       
    93                 TUint8              iShDeviceIdentifier;
       
    94                 // Synch by above mutex.
       
    95                 TBool               iShOldDeviceConnectedState;
       
    96 
       
    97             };
       
    98             
       
    99                 //private:
       
   100         NONSHARABLE_CLASS( TDynamicDevice )
    52             {
   101             {
    53             EISIMediaSharedMemory = 0x00,
   102             public:
    54             EISIMediaTest,
   103                 TDynamicDevice( const TUint8 aDynamicDevId, TUint8 aStaticDevId ){iDynamicDevId = aDynamicDevId; iStaticDevId = aStaticDevId;};
    55             EISIAmountOfMedias
   104                 TUint8 iDynamicDevId;
       
   105                 TUint8 iStaticDevId;
    56             };
   106             };
    57 
   107 
    58         MISIRouterLinkIf**   iLinksArray;
   108         // Additional coding convention iSh-prefix means a member variable shared between N threads.
    59         DISIRouter*          iRouter;
   109         // Owned, called in N thread context
    60     
   110         RPointerArray<DISIDevice> iShDevices;
    61     public:
   111         // Called in N thread context
    62      
   112         DISIRouter&               iShRouter;
    63         static DISICLTransceiver* iThisPtr;   
   113         // Owned, no need to synch only accessed from below DFC function.
       
   114         DIsiRouterService*        iRouterService;
       
   115         // Owned, accessed from N threads no need to synch synch handled internally in TDfc class 
       
   116         TDfc*                     iShStateChangedDfc;
    64         
   117         
       
   118         TDfc*                     iRxQueueDfc;
       
   119         
       
   120         RArray< TDynamicDevice* > iDynamicDeviceTable;
       
   121         
       
   122         DISIMsgQueue*             iRxQueue;
       
   123         
       
   124         static DMutex*            iDynamicDeviceTableMutex;
       
   125        
       
   126         TUint8                    iDevPcLastSendTrxId;
       
   127         TUint8                    iDevPcLastActiveTrxId;
    65     };
   128     };
    66 
   129 
    67 #endif /* __ISICLTRANSCEIVER_H__ */
   130 #endif /* __ISICLTRANSCEIVER_H__ */
    68 
   131