/*
* Copyright (c) 2007-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          : CSipDialogItem.h
* Part of       : SIPDialogs
* Version       : SIP/6.0 
*
*/




/**
 @internalComponent
*/

#ifndef CSIPDIALOGITEM_H
#define CSIPDIALOGITEM_H

#include <e32base.h>
#include <stringpool.h>
#include "SipStackServerDefs.h"
#include "MTransactionOwner.h"
#include "MRefreshOwner.h"
#include "sip.h"
#include "MDialogContext.h"
#include "MSIPSecUser.h"
#include "DialogStateBase.h"
#include "Establishing.h"
#include "Early.h"
#include "Confirmed.h"
#include "Terminated.h"

class MSipRefreshMgr;
class MTransactionUser;
class CSIPSec;
class MDialogOwner;
class CDeleteMgr;
class CDialogsStore;
class CTransactionItemStore;
class CSIPMessage;
class CSIPRouteHeaderBase;
class CSIPRouteHeader;
class CSIPCallIDHeader;
class CSIPContactHeader;
class CURIContainer;
class CSIPURI;
class CSIPAddress;
class CSigCompMgr;
class MSigComp;


class CSipDialogItem : public CBase,
                       public MDialogContext,
                       public MTransactionOwner,
                       public MRefreshOwner,
                       public MSIPSecUser
                       
    {
public: // Constructors and destructor

    static CSipDialogItem* NewLC(
        CDialogsStore& aDialogStore,
        MDialogOwner* aDialogOwner,
        MSIPSecUser& aSIPSecUser,
        MTransactionUser& aTransactionMgr, 
        MSipRefreshMgr& aRefreshMgr,
        CSIPSec& aSIPSec,
        CDeleteMgr& aDeleteMgr,
        MSigComp& aSigComp,
        TRegistrationId aRegistrationId=KEmptyRegistrationId);

    ~CSipDialogItem();
    
    
public: // From MDialogContext
    
    MDialogOwner* DialogOwner();
    
    TDialogId DialogId() const;
    
    TRegistrationId RegistrationId() const;
   
    void SelfDestruct();
    
    TTransactionId FirstTransactionId();
    
    void ChangeState(TDialogStateBase& aState);
    
    void TerminateForkedDialogs(TTransactionId aTransactionId);

    void SetCallId(CSIPCallIDHeader* aCallId);

    CSIPCallIDHeader* CallId();
    
    void SetLocalTag(RStringF aTag);
    
    RStringF LocalTag();

    void SetRemoteTagL(CSIPFromToHeaderBase* aFromTo);
    
    RStringF RemoteTag();
    
    TBool RemoteTagSet();
    
    void SetLocalSeqNum(TUint aNum);
    
    void SetRemoteTargetWithMsgL(CSIPMessage& aMsg);

    void SetRemoteSeqNum(TUint aNum);

    void SetRouteSetUsingRecordRouteL(CSIPMessage& aMessage,
                                      TBool aIsUAC,
                                      TInt aLeaveCode);

    TInt RemoveTransactionItem(TTransactionId& aTransactionId);
        
    TBool HasRouteSet() const;    
    
    void AddCallIdHeaderInDialogL(CSIPMessage& aMessage);
    
    void AddCSeqHeaderInDialogL(CSIPRequest& aRequest);

    
public: // From MDialogContext and MRefreshOwner

    TSIPTransportParams TransportParams(const TRegistrationId& aRegistrationId);    

    
public: // From MTransactionOwner

    void ReceiveL(TUint32 aIapId,
                  TTransactionId aTransaction,
                  CSIPRequest* aReq);
    
    void ReceiveL(TTransactionId aTransaction,
                  CSIPResponse* aMsg);
                  
    TInt TransactionEnded(TUint32 aIapId,
                          TTransactionId aTransaction,
                          TInt aReason);
                          
    TInt NextCSeq(TUint& aCSeq);
    
    const MSIPSecUser* SIPSecUser() const;
    

public: // From MRefreshOwner    
    
    void RefreshReceivedL (TTransactionId aTransactionId,
                           TRefreshId aRefreshId,
                           CSIPResponse* aSIPResponse);

    TInt RefreshError (TRefreshId aRefreshId,
                       TTransactionId aTransactionId,
                       TInt aReason);

    TInt NextRefreshCSeq (TUint& aCSeq);
    
    const MSIPSecUser* SIPSecUser(const TRegistrationId& aRegistrationId);
    
    TUint RefreshDurationL();

public: // From MSIPSecUser

	TBool PassOnlyRealmsToUser() const;
	
    void RequestCredentialsL(const TDesC8& aRealm);
	
    void RequestCredentialsL(CSIPResponse& aResponse,
	                         TTransactionId aTransactionId,
	                         TRefreshId aRefreshId);
    
    const MSIPSecUser* TrustedUser(TRegistrationId aRegistrationId);
    
    TBool ByPassSIPSec() const;
    

public: // New functions    
   
    TUint32 IapId();
   
    static TInt Offset();
 
    void ResetStateL();
 
    TBool IsEarly() const;

    CDeleteMgr& DeleteMgr();
    
    TBool Match(CSIPRequest& aRequest) const;
    
    static TBool ContactOk(const CSIPContactHeader& aContact);

    void SetFirstTransactionId(const TTransactionId& aTransactionId);
    
    CTransactionItemStore& TransactionItems();
    
    TBool HasTransactionItem(TTransactionId aTransactionId);

    TDialogStateBase& CurrentState();
    
    TUint LocalSeqNum();
    
    TUint RemoteSeqNum();

    void SetLocalAddressL(const CSIPAddress& aAddr);

    const CSIPAddress* LocalAddress();

    void SetRemoteAddressL(const CSIPAddress& aAddr);

    const CSIPAddress* RemoteAddress();
    
    void SetInitialRemoteTargetL(CURIContainer& aUri);
    
    void SetRemoteTargetL(CURIContainer& aUri);
    
    CURIContainer* RemoteTarget();

    void SetLocalTargetWithMsgL(CSIPMessage& aMsg,
                                TBool aUpdateSigCompParam=ETrue);
    
    CSIPContactHeader* LocalTarget();
    
    void SetRouteSetUsingRouteL(CSIPMessage& aMessage);
    
    void SetRouteSetL (RPointerArray<CSIPRouteHeaderBase>& aRoute);
    
    void UpdateLocalTargetL(CSIPMessage& aMessage);
    
    void AddRouteToMessageL(CSIPMessage& aMessage);
    
    void AddRecordRouteToMessageL(CSIPMessage& aMessage);
    
    void AddToHeaderInDialogL(CSIPRequest& aRequest);
    
    void AddFromHeaderInDialogL(CSIPRequest& aRequest);    
    
    void EndTransaction(TTransactionId aTransactionId, TInt aReason);


private: // New functions

    CSipDialogItem (CDialogsStore& aDialogStore,
                    MSIPSecUser& aSIPSecUser,
                    MTransactionUser& aTransactionMgr,
                    MSipRefreshMgr& aRefreshMgr,
                    CSIPSec& aSIPSec,
                    CDeleteMgr& aDeleteMgr,
                    MSigComp& aSigComp,
                    TRegistrationId aRegistrationId);

    void ConstructL (MDialogOwner* aDialogOwner);

    void UpdateSigCompL (CURIContainer& aUri);
    void SetLocalTargetL (CSIPContactHeader& aContact, 
                          TBool aUpdateSigCompParam=ETrue);
    void UpdateRemoteTagForRefreshesL (RStringF aRemoteTag);
    void SetRouteSet (RPointerArray<CSIPRouteHeader>* aRouteSet);
    TBool CheckResponse(CSIPResponse* aResponse);
    TBool CheckRequest(CSIPRequest* aRequest);
    TBool CheckContacts(CSIPMessage& aMessage, 
                        TBool aContactRequired=EFalse) const;
    void CheckContactsL(TTransactionId aTransactionId,
                        CSIPResponse& aResponse) const;
    CSipDialogItem* CreateForkingDialogLC();

    void UpdateTransportForNextHopAndLocalTargetL(
        CSIPContactHeader* aLocalContactInOutgoingRequest);

    CSIPURI& ExtractUriL(CSIPContactHeader* aContact);

    // Needed for cleanup of Route-set:
    static void CleanupRouteSet (TAny* aRouteSet);

private: // Data

    TSglQueLink iLink;
    TDialogId iDialogId;
    TRegistrationId iRegistrationId; // Used for filling the Contact hostport
    TTransactionId iFirstTransactionId;
    CDialogsStore& iDialogStore;
    MTransactionUser& iTU;
    MSipRefreshMgr& iRefreshMgr;
    CSIPSec& iSIPSec;
    CDeleteMgr& iDeleteMgr;
    MSigComp& iSigComp;
    MDialogOwner* iDialogOwner;
    MSIPSecUser& iSIPSecUser;
    CTransactionItemStore* iTransactionItemStore;
    CSigCompMgr* iSigCompMgr;
    RStringF iTagParamName;
    RStringF iTransportParamName;
    RStringF iContactHeaderName;

    // States
    TTerminated iTerminated;
    TConfirmed iConfirmed;
    TEarly iEarly;
    TEstablishing iEstablishing;
    TDialogStateBase* iCurrentState;

    // Dialog state data
    CSIPCallIDHeader* iCallId;
    RStringF iLocalTag;
    RStringF iRemoteTag;
    TBool iRemoteTagSet;
    TUint iLocalSeqNum;
    TUint iRemoteSeqNum;
    CSIPAddress* iLocalAddress;
    CSIPAddress* iRemoteAddress;
    CURIContainer* iRemoteTarget;
    CSIPContactHeader* iLocalTarget;
    RPointerArray<CSIPRouteHeader> iRouteSet;
    
private: // For testing purposes

    UNIT_TEST(CSipDialogItemTest)
    UNIT_TEST(CDialogStoreTest)
    UNIT_TEST(CSipDialogMgrTest)
    };

#endif // CSIPDIALOGITEM_H

// End of File