/*
* Copyright (c) 2004-2009 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:
* Name          : CSipCRServerSession.h
* Part of       : SIP Client Resolver
* Version       : 1.0
*
*/




/**
 @internalComponent
*/
#ifndef CSIPCRSERVERSESSION_H
#define CSIPCRSERVERSESSION_H

//  INCLUDES
#include <e32base.h>
#include "_sipcodecdefs.h"
#include "TSipClient.h"

// FORWARD DECLARATIONS
class CSIPCRServer;
class CSIPCRSessionReceiver;
class CSIPCRRequestItem;
class CSIPRequest;
class CSIPResponse;
class CSIPCRITCUtility;
class CSIPResolvedClient;
class CSIPResolvedClient2;
class CSipCrWorkerAo;

// CLASS DEFINITIONS
class CSIPCRServerSession : public CSession2
	{
public: // Constructors and destructor

    static CSIPCRServerSession* NewL(CSIPCRServer& aCRServer);
    static CSIPCRServerSession* NewLC(CSIPCRServer& aCRServer);
    ~CSIPCRServerSession ();

public: // From CSession2

    void ServiceL(const RMessage2& aMessage);

public: // New functions
    
    void WorkerAoRequestCompleted(CSipCrWorkerAo* aWorkerAo);
    
    void RoutingEntryAddedL(const TUid& aUid);

private: // Second phase constructors

    CSIPCRServerSession(CSIPCRServer& aCRServer);
    void ConstructL();

private: // Helper functions

    void DoServiceL (TInt aFunction, const RMessage2& aMessage);

    void ChannelWithResolverL(const RMessage2& aMessage);
    
    void ChannelL(const RMessage2& aMessage);

	void RegisterL(const TUid& aChannelUid);

	void DeregisterL(const TUid& aChannelUid);

	void SetUIDL(const RMessage2& aMessage);

	void CancelRequestL(const RMessage2& aMessage);
	
	void CancelAllRequests();

    void CancelClientReceiveL();

    void ClientReadyToReceiveL(const RMessage2& aMessage);
    
    void ClientReceiveSipResponseL(const RMessage2& aMessage);

    CSIPResponse* ResolveClientL(CSIPRequest& aRequest, TSipClient& aUid);
    
    void ChannelL(TUint32 aRequestId,
                  CSIPRequest& aRequest,
                  const TSipClient& aClientUid,
                  const TUid& aResolverUid);
                  
    void ChannelImplementationL(CSipCrWorkerAo& aWorkerAo);                  
        
    void HandleNextPendingRequestL(CSipCrWorkerAo& aWorkerAo);
                      
	void ChannelUidL( const TSipClient& aClient,
	                  TUid& aChannelUid, 
					  CSIPRequest* aRequest, 
					  CSIPResolvedClient* aResolvedClient );
	                      
	TUint32 CreateRequestId();
	
	TBool FindUid(const RArray<TSipClient>& aUids, 
	              TSipClient& aUid, 
	              TBool aRomBased,
	              TBool aConnected);
	
	typedef TInt (*ThreadFunctionPtr)(TAny* aPtr);
	        
    void CreateWorkerThreadL(
        CSipCrWorkerAo* aWorkerAo,
        ThreadFunctionPtr aThreadFunctionPtr);
	
	static TInt ChannelWorkerThreadFunction(TAny* aPtr);
	
	static TInt ConnectWorkerThreadFunction(TAny* aPtr);
	
	typedef void 
	    (CSIPCRServerSession::*WorkerFunctionPtr)(CSipCrWorkerAo& aWorkerAo);
	
	static TInt WorkerThreadFunctionImpl(
	    TAny* aPtr,
        WorkerFunctionPtr aWorkerFunctionPtr);
	                                     
	void CancelConnectL(CSIPCRRequestItem* aRequestItem);
	
	template<class T> void AddToRequestQueueL( 
	    CSIPCRRequestItem* aRequestItem, 
        T& aResolvedClient);
										
	template<class T> TBool ConnectL( 
	    CSIPCRRequestItem& aRequestItem, 
        T& aResolvedClient);
		
    void ProtectedAddToRequestQueueL(CSIPCRRequestItem* aRequestItem);
    
    void ProtectedRemoveFromRequestQueue(CSIPCRRequestItem* aRequestItem);	
		
    static void RemoveFromRequestQueue(TAny* aCleanupData);	
							                       
private: // Data                    
  
    TUid iClientUid;
    TBool iClientUidSet;
    CSIPCRServer& iCRServer;
    CSIPCRSessionReceiver* iReceiver;    
    RPointerArray<CSIPCRRequestItem> iRequestQueue;
    TUint32 iRequestIdCounter;
    RPointerArray<CSipCrWorkerAo> iWorkerAos;
    RMutex iRequestQueueMutex;  
    
private: // For testing purposes

	UNIT_TEST(CSipCRServerSessionTest)
    };

#endif // CSIPCRSERVERSESSION_H

// End of File