/*
* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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:        Custom plug-in implementations offer their own API documentation
*                where detailed characteristics about how methods declared in this
*                class are implemented.
*
*/








#ifndef SEN_SERVICE_DISPATCHER_H
#define SEN_SERVICE_DISPATCHER_H

#include <flogger.h>
#include <e32property.h>
#include <e32std.h>
#include "senlogger.h"
#include "sendebug.h"

typedef RSenPointerMap<TInt, TInt> RTransactionsMap;

// FORWARD DECLARATIONS
class CSenConnectionChunk;
class CSenAsyncOperation;
class CSenServiceConnectionImpl;
    
struct TMessage
{
    CSenConnectionChunk* iSenConnectionChunk;   // Not Owned
    CSenAsyncOperation* iSenAsyncOperation; // Not Owned
};
        
struct TThreadMessage
{
    TMessage iMessage;
    TInt iVrtalTrnsnID;
};

#ifdef EKA2
NONSHARABLE_CLASS(CSenServiceDispatcher) : public CBase
#else
class CSenServiceDispatcher : public CBase
#endif
    {
    private:
    protected:
    public:

        // Constructors and destructor:
        static CSenServiceDispatcher* NewL(   RSenServiceConnection&  aConnection,
                                                        TInt aConnectionID);

        static CSenServiceDispatcher* NewLC(  RSenServiceConnection&  aConnection,
                                                        TInt aConnectionID);


        static TInt DispatcherThreadL(CSenServiceDispatcher* aThis);

        static TInt ExecuteL(CSenServiceDispatcher* aThis);

        TInt GetDispactherThreadId();

        TInt AddToTheQueue(TThreadMessage aThreadMessage);

        TBool RemoveFromQueue(TInt aTransactionID);

        TInt AddToTheTransMap(TInt* pVrtlaTxnId,TInt* pActlTxnId);

        TInt RemoveFromTransMap(TInt* pVrtlaTxnId);

        TInt UpdateTransMap(TInt* pVrtlaTxnId,TInt* pActlTxnId);

        TInt GetActualTransactionID(TInt* pVrtlaTxnId);

        TInt GetVirtualTransactionID(TInt* pActlTxnId);

        void SetOwnerThreadId(TInt aOwnerThreadID);

        void ResetQueue();

        TMessage GetMessageFromQueue(TInt aTransactionID);
        
        virtual ~CSenServiceDispatcher();

    private:

        /**
        * C++ default constructor.
        */
        CSenServiceDispatcher(RSenServiceConnection&  aConnection);

        /**
        * By default Symbian 2nd phase constructor is private.
        */
        void ConstructL(TInt aConnectionID);

        RTransactionsMap& TransactionMap();
        
        void OpenDispatcherLogL();

        void CloseDispatcherLogL();
        
    private:

        RThread                             iDispatcherThread;
        
        //Message queue to dispacth messages in FIFO order.
        RArray<TThreadMessage>              iMessageQueue;
        TInt                                iMessagesQueueCounter;
        
        //Map of virtual and actual transaction ID's.
        RTransactionsMap*                   ipTransactionsMap;
        
        //Flag for dispatching messages. Stops dispatching messages
        //when set to FALSE.
        TBool                               iDispatchMessages;
        
        //Synchronizer critical section. Used to lock while dispatching
        //messages.
        RCriticalSection                    iCsSynchronizer;
        
        //Crtitical senction for message queue. 
        RCriticalSection                    iCsMessageQueue;
        
        //Crtitical senction for transaction map. 
        RCriticalSection                    iCsTransctnsMap;
        
        TThreadId                           iOwnerThreadId;
        RSenServiceConnection&              iConnection;    // not owned        
        TInt                                iConnectionID;

    };

#ifdef EKA2
NONSHARABLE_CLASS(CSenUnderTakerWaiter) : public CActive
#else
class CSenUnderTakerWaiter : public CActive
#endif
    {
    public:
        // Constructors and destructor
        static CSenUnderTakerWaiter* NewL(CSenServiceConnectionImpl* aSenServiceConnectionImpl,
                                          TInt aDispatcherThreadID );
        static CSenUnderTakerWaiter* NewLC(CSenServiceConnectionImpl* aSenServiceConnectionImpl,
                                           TInt aDispatcherThreadID);

        void StartWaiter();
        void StopWaiter();

        ~CSenUnderTakerWaiter();

    private:
        CSenUnderTakerWaiter();
        void ConstructL(CSenServiceConnectionImpl* aSenServiceConnectionImpl,
                        TInt iDispatcherThreadID );
        void RunL();
        void DoCancel();
    private: // Data
        CSenServiceConnectionImpl*          iSenServiceConnectionImpl;  // not owned        
        RUndertaker                         iUnderTaker;
        TInt                                iDyingThreadNumber ;
        TInt                                iDispatcherThreadID ;
    };

#endif  //SEN_SERVICE_DISPATCHER_H

// End of File