/*
* 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          : CSipRefreshBase.h
* Part of       : SIPRefreshes
* Version       : SIP/6.0 
*
*/




/**
 @internalComponent
*/


#ifndef CSIPREFRESHBASE_H
#define CSIPREFRESHBASE_H

#include <e32base.h>
#include "SipStackServerDefs.h"
#include "MTransactionOwner.h"
#include "Lwtimer.h"
#include "MSIPSecUser.h"
#include "_sipcodecdefs.h"

class MTransactionUser;
class CSipRefreshMgr;
class MRefreshOwner;
class CSIPRequest;
class CSIPResponse;
class CURIContainer;
class CSIPHeaderBase;
class CSIPRouteHeader;
class MTransactionHeaders;
class CSIPSec;


class CSipRefreshBase : public CBase,
                        public MTransactionOwner,
                        public MExpirationHandler,
                        public MSIPSecUser
    {
public:

    virtual ~CSipRefreshBase ();

    void ClearTransactionOwner ();

    MRefreshOwner* Owner();

    const TRefreshId& Id () const;
    
    TTransactionId CurrentTransactionId() const;

    CSIPRequest* Request();
    
    void SetIntervalL(TInt aInterval);
    
    TInt Interval() const;
    
    void SetRequest(CSIPRequest* aRequest, TBool aDeleteRequest);

    void SendL (TTransactionId& aTransactionId, 
                CSIPRequest* aRequest);

    MTransactionHeaders* SendAndGetHeadersL (TTransactionId& aTransactionId, 
                                             CSIPRequest*    aRequest);

    void UpdateRemoteTargetL(CURIContainer& aRemoteTarget);

    void SetUpdatedHeader(CSIPHeaderBase* aHeader);

    void SetUpdatedRouteHeadersL(const RPointerArray<CSIPRouteHeader>& 
                                 aHeaderArray);

    void RemoveRouteHeaders();

    void UpdateRequestL (TTransactionId& aTransactionId,
                         CSIPRequest* aRequest);

    void TerminateRequestL (TTransactionId& aTransactionId,
                            CSIPRequest* aRequest);

    TUint IAPId () const;

    void ResetRegistrationId();

    void UpdateCSeqValueL(CSIPRequest& aRequest);

	void StopTimer();

public: // From MTransactionOwner

    void ReceiveL(TUint32        aIapId, 
                  TTransactionId aTransactionId, 
                  CSIPRequest*   aRequest);

    void ReceiveL(TTransactionId aTransactionId,
                  CSIPResponse* aResponse);

    TInt TransactionEnded(TUint32 aIapId, 
                          TTransactionId aTransactionId, 
                          TInt aReason);

    TInt NextCSeq(TUint& aCSeq);
    
    virtual const MSIPSecUser* SIPSecUser() const;

public: // From MExpirationHandler

    void TimerExpiredL (TTimerId aTimerId, TAny* aTimerParam);
    
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;

protected:

    CSipRefreshBase (MTransactionUser& aTU,
                     MTimerManager&    aTimerMgr,
                     CSIPSec&          aSIPSec,
                     CSipRefreshMgr&   aRefreshMgr,
                     TRegistrationId   aRegistrationId,
                     MRefreshOwner*    aOwner,
                     MSIPSecUser&      aSIPSecUser);

    void BaseConstructL(CURIContainer& aRemoteTarget,
                        CSIPRequest& aRequest);

    virtual void Forward2xxResponseToCallerL(CSIPResponse* aResponse) = 0;

    

    virtual void SetExpirationTimeToRequestL(CSIPRequest& aRequest,
                                             TUint aExpirationTimeInSeconds) = 0;

    virtual void SetExpirationTimeToResponseL(CSIPResponse& 
                                              aResponse,
                                              TUint 
                                              aExpirationTimeInSeconds) = 0;

    virtual void CheckUpdateRequestExpiresValueL(CSIPRequest& aRequest) = 0;

    virtual void CheckTerminateRequestExpiresValueL(CSIPRequest& aRequest) = 0;

    virtual TInt ExpirationTimeFromResponse(CSIPResponse& aResponse) = 0;

    virtual TInt ExpirationTimeFromRequestL(CSIPRequest& aRequest) = 0;
    
    void Received200ClassResponseL(CSIPResponse* aResponse);
    void ReceivedProvisonalResponseL(CSIPResponse* aResponse);
    void ReceivedErrorResponseL(CSIPResponse* aResponse);

    TInt ExpireTimeFromResponseExpiresHeader(CSIPResponse& aResponse);
    void SetExpireTimeToResponseExpiresHeaderL(CSIPResponse& 
                                               aResponse,
                                               TUint 
                                               aExpirationTimeInSeconds);

    void UpdateHeaderForL(CSIPRequest& aRequest);

    void UpdateRouteHeadersForL(CSIPRequest& aRequest);

    void RemoveRouteHeadersFor(CSIPRequest& aRequest);

    void SetToFromOriginalRequestL(CSIPRequest& aRequest);

    void SetFromFromOriginalRequestL(CSIPRequest& aRequest);

    void SetCallIdFromOriginalRequestL(CSIPRequest& aRequest);

    void SetCSeqFromOriginalRequestL(CSIPRequest& aRequest);

    void RefreshReceivedL(TTransactionId aTransactionId, 
                          CSIPResponse*  aResponse);

    void CheckUpdateRequestMethodL(CSIPRequest& aRequest);

    void CheckUpdateRequestHeadersL(CSIPRequest& aRequest);

private:

    void SendUpdateRequestL (TTransactionId& aTransactionId,
                             CSIPRequest*    aRequest);

    void StartTimerL(TInt aMilliSeconds);
    
    TInt CalculateInterval(TInt aValueInSeconds) const;

    TInt RefreshErrorOccured(TTransactionId aTransactionId, TInt aError);

protected: // Data

    CSipRefreshMgr&               iRefreshMgr;
    TRefreshId                    iRefreshId;
    CSIPRequest*                  iRequest;
    CURIContainer*                iRemoteTarget;    
    TTransactionId                iCurrentTransactionId;
    TBool                         iFirstRequest;
    MSIPSecUser&                  iSIPSecUser;
    MRefreshOwner*                iOwner;
    
private: // Data

    MTransactionUser&             iTU;
    MTimerManager&                iTimerMgr;
    CSIPSec&                      iSIPSec;
    TBool                         iTransactionOwnerCleared;
    TInt                          iIntervalInMilliSeconds;
    TBool                         iIntervalUpdated;   
    TRegistrationId               iRegistrationId;
    TTimerId                      iTimerId;
    CSIPHeaderBase*               iUpdatedHeader;
    RPointerArray<CSIPHeaderBase> iUpdatedRouteHeaders;
    TBool                         iOwnRequest;
    TBool                         iRemoveRouteHeaders;
    
private: // For testing purposes

    UNIT_TEST(CSipRefreshMgrTest)
    UNIT_TEST(CSipRegisterRefreshTest)
    };

#endif // CSIPREFRESHBASE_H

// End of File