/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
* 
* Description: 
*
*/



#ifndef __P2PKERNELCHANNEL_H_
#define __P2PKERNELCHANNEL_H_

#include <e32def.h>                 // For TInt, TAny
#include <e32cmn.h>                 // For TDesC8, 
#include <kernel.h>                 // For TMessageQue;
#include "p2prouterchannelifs.h"    // For MP2PRouterChIf

// Forward declarations
class TDfc;
class MP2PChRouterIf;
class TThreadMessage;
class DMsgQueue;

/*
* Kernel side P2P channel.
*/
NONSHARABLE_CLASS( DP2PKernelChannel ) : public MP2PRouterChIf
    {

    public:

        /*
        * Default constructor
        */
        DP2PKernelChannel();

        /*
        * Destructor
        */
        ~DP2PKernelChannel();

        /*
        * Handles the thread message. Synchronizes the execution
        * from multiple client threads to single thread.
        * @param aMsg, thread message
        * @return, return value of the operation.
        */
        TInt HandleRequest( TThreadMessage& aMsg );

        // From MP2PRouterChIf start
        /*
        * See comments from MP2PRouterChIf.
        */
        void ConnectionLost();

        /*
        * See comments from MP2PRouterChIf.
        */
        void EnqueChannelRequestCompleteDfc( TInt aRequest, TInt aStatusToComplete );

        /*
        * See comments from MP2PRouterChIf.
        */
        void ReceiveMsg( const TDesC8& aMessage );
        // From MP2PRouterChIf end

    private:

        void Close( const TUint8 aP2PProtocolId );

        void Closing( const TUint8 aP2PProtocolId );

        static void EmptyRxDfc( TAny* aPtr );

        /*
        * iKernelChMsgQue callback function in p2p router
        * thread context.
        * @param aPtr, pointer to self
        */
        static void MsgQDfc( TAny* aPtr );

        void HandleThreadMsg( TThreadMessage& aMsg );

        void HandleDfcRequest( TThreadMessage& aMsg );

        TInt HandleSyncRequest( TThreadMessage& aMsg );

        void DoCancel( TInt aRequest, TInt aMask );

        void ResetQueues();

        /*
        * Internal class for handling requests.
        */
        NONSHARABLE_CLASS( DP2PKernelAsyncRequests ) : public DBase
            {

            public:

                /*
                * Constructor
                * @param aSize, sife of the request list.
                */
                DP2PKernelAsyncRequests( const TInt aSize );

                /*
                * Destructor
                */
                ~DP2PKernelAsyncRequests();

                /*
                * Completes the request if it is pending.
                * Do not call with FM held.
                * @param aRequest, request to complete
                * @param aStatusToComplete, completion status to request to complete
                */
                void Complete( const TUint aRequest, const TInt aStatusToComplete );
                
                /*
                * Check does is the request pending.
                * Do not call with FM held.
                * @param  aRequest, request to check
                */
                TBool IsPending( const TUint aRequest );
                
                /*
                * Set the request pending.
                * Do not call with FM held.
                * @param aRequest, request to set pending
                * @param aDfc, pointer to DFC function which is enqued when request is completed
                * @param aStatus, pointer to status which is modified when request is completed
                */
                void SetPending( const TUint aRequest, TDfc* aDfc, TInt* aStatus );

            private:

                // Added convention:
                // Prefix "iSh" means shared member variable
                // Prefix "gSh" means shared global variable

                // Guarding lock.
                NFastMutex* iRequestLock;
                TDfc**      iShDfcFunctionList;
                TInt**      iShRequestStatusList;

            };

  private:

        // Protocol id of this channel.
        // Only acccessed from p2p router thread.
        TUint8                      iP2PProtocolId;
        // Owned, synhronized internally with fastmutexes
        DMsgQueue*                  iRx;
        // Owned
        TDfc*                       iEmptyRxDfc;
        // Not owned, just using
        // Only acccessed from p2p router thread.
        TDes8**                     iPtrPtrToRxBuf;
        MP2PChRouterIf*             iRouterIf;
        TMessageQue                 iKernelChMsgQue;
        // Synhronized internally with fastmutexes
        DP2PKernelAsyncRequests*    iRequests;

    };



#endif /* __P2PKERNELCHANNEL_H_ */