// 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          : SIPRefresh.cpp
// Part of       : SIPAPI
// Version       : SIP/4.0 
//



#include "sipdefs.h"
#include "siperr.h"
#include "SipAssert.h"
#include "sipstrings.h"
#include "sipclientconnection.h"
#include "siprefresh.h"
#include "sipclienttransaction.h"
#include "siprefreshassociation.h"
#include "transactionassociation.h"


#ifdef CPPUNIT_TEST

#include "TestCleanupStack.h"

#undef EXPORT_C
#define EXPORT_C

#endif


// -----------------------------------------------------------------------------
// CSIPRefresh::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRefresh* CSIPRefresh::NewL()
    {
    CSIPRefresh* self = CSIPRefresh::NewLC();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRefresh* CSIPRefresh::NewLC()
    {
    CSIPRefresh* self = new (ELeave) CSIPRefresh();
    CleanupStack::PushL(self);    
    self->ConstructL();    
    return self;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::CSIPRefresh
// -----------------------------------------------------------------------------
//
CSIPRefresh::CSIPRefresh() : iState(EConstructing)
    {
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPRefresh::ConstructL()
	{
	SIPStrings::OpenL();
	iState = EInactive;
	}

// -----------------------------------------------------------------------------
// CSIPRefresh::~CSIPRefresh
// If iState is EConstructing, string pool was not opened.
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRefresh::~CSIPRefresh()
    {
    if (iClientTransaction)
        {
        iClientTransaction->RemoveRefresh();
        }

    if (iOwner)
        {
        iOwner->DeletingRefresh(*this, iRefreshId);
        }

    iRequestType.Close();
    if (iState != EConstructing)
    	{
    	SIPStrings::Close();
    	}
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::State
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRefresh::TState CSIPRefresh::State() const
    {
    return iState;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::IsStandAlone
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPRefresh::IsStandAlone() const
	{	
	return iOwner && (iOwner->CheckIfStandAlone() == KErrNone);
	}

// -----------------------------------------------------------------------------
// CSIPRefresh::SIPTransaction
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPClientTransaction* CSIPRefresh::SIPTransaction() const
    {
    return iClientTransaction;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::TerminateL
// No need to check if this is a standalone refresh, as UpdateRefreshL leaves
// with the proper error if this refresh isn't standalone.
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPRefresh::TerminateL(CSIPMessageElements* aElements)
    {
    CheckStateL();
    return iOwner->UpdateRefreshL(*this, aElements, ETrue);
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::UpdateL
// No need to check if this is a standalone refresh, as UpdateRefreshL leaves
// with the proper error if this refresh isn't standalone.
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPRefresh::UpdateL(CSIPMessageElements* aElements)
    {
	CheckStateL();
    return iOwner->UpdateRefreshL(*this, aElements, EFalse);
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::operator==
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPRefresh::operator==(const CSIPRefresh& aRefresh) const
    {
    if (!iRefreshId || !aRefresh.iRefreshId)
        {
        //If either of the ids is empty, the refreshes are not considired same,
        //unless the objects are actually same
        return this == &aRefresh;
        }

    return iRefreshId == aRefresh.iRefreshId;    
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::IntervalL
// Allow getting interval even before active state.
// -----------------------------------------------------------------------------
//
EXPORT_C TUint CSIPRefresh::IntervalL() const
	{
	__ASSERT_ALWAYS(iOwner, User::Leave(KErrSIPResourceNotAvailable));

	return iOwner->TransactionAssociation().ClientConnectionL().
		RefreshIntervalL(iRefreshId);
	}

// -----------------------------------------------------------------------------
// CSIPRefresh::SetIntervalL
// Allow interval setting even before active state.
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPRefresh::SetIntervalL(TUint aInterval)
	{
	__ASSERT_ALWAYS(iOwner, User::Leave(KErrSIPResourceNotAvailable));
    __ASSERT_ALWAYS(aInterval > 0, User::Leave(KErrArgument));

	return iOwner->TransactionAssociation().ClientConnectionL().
		SetRefreshIntervalL(iRefreshId, aInterval);
	}

// -----------------------------------------------------------------------------
// CSIPRefresh::SetRefreshOwner
// -----------------------------------------------------------------------------
//
void CSIPRefresh::SetRefreshOwner(MSIPRefreshAssociation& aAssoc)
    {
    iOwner = &aAssoc;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::RemoveRefreshOwner
// -----------------------------------------------------------------------------
//
void CSIPRefresh::RemoveRefreshOwner(const MSIPRefreshAssociation& aAssoc)
    {
    __SIP_ASSERT_RETURN(iOwner == &aAssoc, KErrUnknown);
    
    iOwner = NULL;    
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::ChangeState
// -----------------------------------------------------------------------------
//
void CSIPRefresh::ChangeState(CSIPRefresh::TState aNextState)
    {
    iState = aNextState;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::RefreshId
// -----------------------------------------------------------------------------
//
TUint32 CSIPRefresh::RefreshId() const
    {
    return iRefreshId;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::SetRefreshIdIfEmpty
// -----------------------------------------------------------------------------
//
void CSIPRefresh::SetRefreshIdIfEmpty(TUint32 aRefreshId)
    {    
    if (!iRefreshId)
        {        
        iRefreshId = aRefreshId;
        }
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::RequestType
// -----------------------------------------------------------------------------
//
RStringF CSIPRefresh::RequestType() const
    {
    return iRequestType;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::SetRequestType
// -----------------------------------------------------------------------------
//
void CSIPRefresh::SetRequestType(RStringF aType)
    {
    iRequestType.Close();
	iRequestType = aType.Copy();	
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::DoesMatch
// -----------------------------------------------------------------------------
//
TBool CSIPRefresh::DoesMatch(TUint32 aRefreshId) const
    {
    return aRefreshId == iRefreshId;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::AddTransaction
// Refresh is associated to a new client transaction. iClientTransaction might
// be non-NULL in case application has not deleted the previous transaction yet.
// -----------------------------------------------------------------------------
//
void CSIPRefresh::AddTransaction(CSIPClientTransaction& aTransaction)
    {
    //Remove possibly existing association to current transaction
    if (iClientTransaction)
        {
        iClientTransaction->RemoveRefresh();
        }

    iClientTransaction = &aTransaction;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::RemoveTransaction
// -----------------------------------------------------------------------------
//
void CSIPRefresh::RemoveTransaction()
    {
    __SIP_ASSERT_RETURN(iClientTransaction, KErrNotFound);

    iClientTransaction = NULL;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::Transaction
// -----------------------------------------------------------------------------
//
CSIPClientTransaction* CSIPRefresh::Transaction()
    {
    return iClientTransaction;
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::UpdateRefreshState
// -----------------------------------------------------------------------------
//
void CSIPRefresh::UpdateRefreshState(TUint aStatusCode)
    {
    if (aStatusCode >= 300)
        {
        ChangeState(CSIPRefresh::ETerminated);
        }
    else
        {
        if (aStatusCode >= 200)
            {
            ChangeState(CSIPRefresh::EActive);
            }
        }
    }

// -----------------------------------------------------------------------------
// CSIPRefresh::CheckStateL
// -----------------------------------------------------------------------------
//
void CSIPRefresh::CheckStateL() const
	{
	__ASSERT_ALWAYS(iState == EActive,
    				User::Leave(KErrSIPInvalidTransactionState));
    __ASSERT_ALWAYS(iOwner, User::Leave(KErrSIPResourceNotAvailable));
	}