/*
* Copyright (c) 2005-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          : CSipDialogMgr.h
* Part of       : SIPDialogs
* Version       : SIP/4.0 
*
*/




/**
 @internalComponent
*/

#ifndef CSIPDIALOGMGR_H
#define CSIPDIALOGMGR_H

#include <e32base.h>
#include <stringpool.h>
#include "SipStackServerDefs.h"
#include "sipinternalstates.h"
#include "MSipDialogs.h"
#include "MConnectionStateObserver.h"

class CSipDialogItem;
class CDialogsStore;
class MSipRegistrationContact;
class MTransactionUser;
class MTransactionHeaders;
class MSipRefreshMgr;
class MDialogOwner;
class CDeleteMgr;
class CSIPFromToHeaderBase;
class CSIPFromHeader;
class CSIPToHeader;
class CSIPRouteHeaderBase;
class CURIContainer;
class CSIPContactHeader;
class CSIPCallIDHeader;
class CSIPMessage;
class CEstablishing;
class CEarly;
class CConfirmed;
class CTerminated;
class CSIPSec;
class MSIPSecUser;
class MSigComp;
class TSIPTransportParams;


/**
 * Dialog manager creates, controls and deletes dialogs.
 * Dialog manager provides requests and responses from server core to transaction user.
 * Transaction user responses for requests provided by dialog manager and dialog manager
 * creates dialogs for successfull requests. 
 * Dialog manager includes dialogs, which contain states. When provisional response is got
 * for a request dialog is created. Dialogs states are also provided.
 */
class CSipDialogMgr : public CBase,
					  public MSipDialogs,
					  public MConnectionStateObserver
    {
public: // Constructors and destructor
	
    static CSipDialogMgr* NewL(MTransactionUser& aTU,
                               MSipRefreshMgr& aRefreshMgr,
                               MSipRegistrationContact& aRegistrationContact,
                               CSIPSec& aSIPSec,
                               MSigComp& aSigComp);
    ~CSipDialogMgr ();


public: // From MSipDialogs

	MTransactionOwner* TransactionOwnerL(CSIPRequest& aRequest,
	                                     CSIPResponse** aResponse);


public: // From MConnectionStateObserver

	void ConnectionStateChangedL(TUint32 aIapId,
                                 CSIPConnection::TState aState);


public: // New functions

	/**
	* Dialog manager creates dialog and 
    * sends request provided by server core to TU or Refreshes.
	*
    * @pre aSipRequest != 0
    * @pre aOwner != 0
    *
	* @param aTransactionId on return contains the id 
	*        of the created transaction
	* @param aRefreshId if the request is refreshed 
	*        on return contains the id of the created refresh	
	* @param aRegistrationId a registration id with 
	*        which a possible outbound proxy is used in TU.
	* @param aDialogId on return contains the id of the created dialog
	* @param aSipRequest a SIP Request to be sent. 
	*        The ownership is transferred.
    * @param aRemoteTarget; a remote target to be copied 
    *        to the dialog to be established.
	* @param aOwner Dialog owner
	* @param aSIPSecUser a user of SIPSec
	* @param aRefresh If EFalse, the request will be sent to TU. 
    *        Otherwise a refresh is created.
	*/
	void SendAndCreateDialogL(TTransactionId& aTransactionId,
	                          TRefreshId& aRefreshId,
	                          TRegistrationId aRegistrationId,
	                          TDialogId& aDialogId,
	                          CSIPRequest* aSipRequest,
	                          CURIContainer& aRemoteTarget,
	                          MDialogOwner* aOwner,
	                          MSIPSecUser& aSIPSecUser,
	                          TBool aRefresh=EFalse);

	/**
	* Dialog already created. Request is sent within a dialog.
	*	 
	* @param aTransactionId on return contains the id 
	*        of the created transaction
	* @param aRefreshId if the request is refreshed 
	*        on return contains the id of the created refresh
	* @param aDialogId an existing dialog id
	* @param aSipRequest SIP Request. The ownership is transferred.
	* @param aOwner Dialog owner
	* @param aRefresh If EFalse, request will be sent TU.
    *        Otherwise a new refresh is created. 
	* @param aAllowOverlap If ETrue, any requests can be sent.
    *        Otherwise requests with the same method are not allowed
	*		  while this request is pending.
	* @param aTargetRefresh If ETrue, localand remote target will be updated.
	*/	                           
	void SendWithinDialogL(TTransactionId& aTransactionId,
	                       TRefreshId& aRefreshId,
	                       const TDialogId& aDialogId,
	                       CSIPRequest* aSipRequest,
	                       const MDialogOwner* aOwner,
	                       TBool aRefresh=EFalse,
	                       TBool aAllowOverlap=ETrue,
	                       TBool aTargetRefresh=EFalse);

	/**
	* Dialog already created. Request is sent within a dialog and
    * an exiting refresh is updated.
	*	
	* @param aTransactionId transaction id
    * @param aRefreshId an existing refresh id
	* @param aDialogId an existing dialog id
	* @param aSipRequest SIP Request. The ownership is transferred.
	* @param aOwner Dialog owner
	*/
	void SendAndUpdateRefreshL(TTransactionId& aTransactionId,
	                           const TRefreshId& aRefreshId,
	                           const TDialogId& aDialogId,
	                           CSIPRequest* aSipRequest,
	                           const MDialogOwner* aOwner);

	/**
	* Dialog manager creates dialog and sends the response to TU.
	*
	* @param aTransactionId Transaction id
	* @param aRegistrationId a registration id with 
	*        which a possible outbound proxy is used in TU.
	* @param aDialogId Dialog id 
	* @param aSipResponse SIP Response. The ownership is transferred.
	* @param aOwner Dialog owner
	* @param aSIPSecUser a user of SIPSec
	*/
	void SendAndCreateDialogL(const TTransactionId& aTransactionId,
							  TRegistrationId aRegistrationId,
	                          TDialogId& aDialogId,
	                          CSIPResponse* aSipResponse,
	                          MDialogOwner* aOwner,
	                          MSIPSecUser& aSIPSecUser);

	/**
	* Dialog already created. Response is sent within a dialog. 
	*
	* @param aTransactionId transaction id
	* @param aDialogId an existing dialog id
	* @param aSipResponse SIP Response. The ownership is transferred.
	* @param aOwner Dialog owner
	* @param aTargetRefresh If ETrue, remote and local targets are updated.
	*/
	void SendWithinDialogL(const TTransactionId& aTransactionId,
	                       const TDialogId& aDialogId,
	                       CSIPResponse* aSipResponse,
	                       const MDialogOwner* aOwner,
	                       TBool aTargetRefresh=EFalse);

    /**
	* The dialog is removed. 
    * Dialogs will not anymore call the dialog owner.
	*
	* @param aDialogId an existing dialog id
	* @param aOwner Dialog owner
    * @returns KErrNone if the dialog was found, otherwise KErrNotFound
	*/
	TInt TerminateDialog(const TDialogId& aDialogId,
	                     const MDialogOwner* aOwner);

	/**
	* All the dialogs for a dialog owner are removed.
    * Dialogs will not anymore call the dialog owner.
	*
	* @param aDialogId	an existing dialog id
    * @returns KErrNone if dialogs for the owner were found,
    *          otherwise KErrNotFound.
	*/
    TInt TerminateDialogsFor(const MDialogOwner* aOwner);
	
    /**
    * Terminates a refresh within a dialog abnormally. 
    *
    * @param aDialogId an existing dialog id
    * @param aRefreshId an existing refresh id
    * @param aOwner Dialog owner
    * @returns KErrNone if the dialog and the refrsh were found,
    *          otherwise KErrNotFound.
    */	
    TInt TerminateDialogRefresh(const TDialogId& aDialogId,
                                const TRefreshId& aRefreshId,
                                const MDialogOwner* aOwner);

    /**
    * Gets existing dialogs state if the dialog is not found
    * leaves with KErrNotFound
    *
    * @param aDialogId an existing dialog id
    * @param aState contains dialog state 
    */
	void GetStateL(const TDialogId& aDialogId,
	               CSIPInternalStates::TState& aState);

    /**
    * Gets a Call-ID-header related the given dialog id.
    * Leaves with KErrNotFound if the dialog was not found.
    *
    * @param aDialogId an existing dialog id
    * @param aOwner Dialog owner
    * @returns a Call-ID-header related to the dialog
    */
	const CSIPCallIDHeader& CallIDL(const TDialogId& aDialogId,
	                                const MDialogOwner* aOwner);
	 
    /**
    * Gets the local tag related the given dialog id.
    * Leaves with KErrNotFound if the dialog was not found.
    *
    * @param aDialogId an existing dialog id
    * @param aOwner Dialog owner
    * @returns the local tag related to the dialog
    */	                                
	const TDesC8& LocalTagL(const TDialogId& aDialogId,
	                        const MDialogOwner* aOwner);

    /**
	* Resets the state of the dialog but keeps the data such as 
	* Call-ID, CSeq, local and remote target, local tag and route set.
	*
	* @param aDialogId an existing dialog id
	* @param aOwner Dialog owner
	*/    
	void ResetStateL(const TDialogId& aDialogId,
	                 const MDialogOwner* aOwner);
	                 
	/**
	 * Gets a MSIPSecUser related to a transaction.
     *
     * @param aTransactionId the transaction id
     *
     * @return MSIPSecUser related to the given transaction id, if found,
     *         otherwise NULL.
	 */    
    const MSIPSecUser* SIPSecUserForTransaction(
        const TTransactionId& aTransactionId);	                 


private: // New functions

    CSipDialogMgr (MTransactionUser& aTU,
                   MSipRefreshMgr& aRefreshMgr,
                   MSipRegistrationContact& aRegistratinonContact,
                   CSIPSec& aSIPSec,
                   MSigComp& aSigComp);
    
	void ConstructL ();
	
    CSIPContactHeader* ExtractContactL (
        TTransactionId aTransactionId,
        MTransactionHeaders& aHeaders,
        const TSIPTransportParams& aParams,
        TBool aContactMandatory);
                                        
    void CheckRecordRouteL (TTransactionId aTransactionId,
                            RPointerArray<CSIPRouteHeaderBase>& aRecordRoute,
                            const TSIPTransportParams& aParams);                                   

    void AddContactHeaderL (TUint32 aIapId,
                            TRegistrationId aRegistrationId,
                            CSIPRequest& aRequest,
                            const CSIPFromHeader* aFrom);

    void AddContactHeaderL (TUint32 aIapId,
                            CSIPResponse& aResponse,
                            const CSIPToHeader* aTo,
							const CURIContainer& aRequestUri);

	void AddContactHeaderL (CSipDialogItem& aDialog,
                            CSIPMessage& aMessage,
                            const CSIPFromToHeaderBase* aFromTo,
                            TBool aTargetRefresh);

	void CreateAndAddContactL (TUint32 aIapId,
	                           TRegistrationId aRegistrationId,
                               CSIPMessage& aMessage,
                               const CSIPFromToHeaderBase* aFromTo);

	void FillHostInContactL (TUint32 aIapId,
	                         TRegistrationId aRegistrationId,
		                     CSIPMessage& aMessage,
							 const CSIPFromToHeaderBase* aFromTo);

	void CreateAndAddContactL (const CURIContainer& aUri,
	                           CSIPMessage& aMessage);
	                                                    
	void SendErrorResponseAndLeaveL (TTransactionId aTransactionId,
	                                 TInt aLeaveCode,
	                                 const TSIPTransportParams& aParams);
	                                 
	static void DeleteTransactionHeaders (TAny* aTransactionHeaders);
	
	static void DeleteRouteSet (TAny* aRouteSet);
	
	static void DeleteContacts (TAny* aContacts);	


private: // Data

    MTransactionUser& iTU;
	MSipRefreshMgr& iRefreshMgr;
	MSipRegistrationContact& iRegistrationContact;
	CSIPSec& iSIPSec;
	MSigComp& iSigComp;
	CDeleteMgr*	iDeleteMgr;
	CDialogsStore* iDialogsStore;
	RStringF iContactHeaderName;
	RStringF iRouteHeaderName;
	RStringF iTagParamName;
	RStringF iPhraseCallTransactionDoesNotExist;
	RStringF iPhraseBadRequest;
    
private: // For testing purposes

	UNIT_TEST(CSipDialogMgrTest)
    };

#endif // CSIPDIALOGMGR_H

// End of File