// Copyright (c) 2006-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          : registered.cpp
// Part of       : SIPAPI
// Version       : SIP/5.0
//



#include "sip.h"
#include "siperr.h"
#include "SipAssert.h"
#include "registered.h"
#include "RegBindingImplementation.h"
#include "sipresponseelements.h"
#include "sipclienttransaction.h"
#include "sipconnectioncallback.h"


// -----------------------------------------------------------------------------
// CRegistered::NewL
// -----------------------------------------------------------------------------
//
CRegistered* CRegistered::NewL()
	{
	return new (ELeave) CRegistered();
	}

// -----------------------------------------------------------------------------
// CRegistered::CRegistered
// -----------------------------------------------------------------------------
//
CRegistered::CRegistered()
	{
	}

// -----------------------------------------------------------------------------
// CRegistered::~CRegistered
// -----------------------------------------------------------------------------
//
CRegistered::~CRegistered()
	{
	}

// -----------------------------------------------------------------------------
// CRegistered::IsContextActive
// -----------------------------------------------------------------------------
//
TBool CRegistered::IsContextActive() const
    {
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CRegistered::SetNeighbourStates
// -----------------------------------------------------------------------------
//
void CRegistered::SetNeighbourStates(CRegistrationState& aUnregistering,
                                     CRegistrationState& aUnregistered)
    {
    iUnregistering = &aUnregistering;
    iUnregistered = &aUnregistered;
    }

// -----------------------------------------------------------------------------
// CRegistered::DeregisterL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction* 
CRegistered::DeregisterL(CRegBindingImplementation& aRegistration,
                         CSIPMessageElements* aElements) const
    {
    CSIPClientTransaction* ta = aRegistration.DoDeregisterL(aElements);
    aRegistration.ChangeState(iUnregistering);

    return ta;
    }

// -----------------------------------------------------------------------------
// CRegistered::UpdateL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CRegistered::UpdateL(CRegBindingImplementation& aRegistration,
                     CSIPMessageElements* aElements,
                     TUint* aExpirationValue) const
    {    
    return aRegistration.DoUpdateL(aElements, aExpirationValue);
    }

// -----------------------------------------------------------------------------
// CRegistered::IncomingResponseL
// When an existing refreshed registration ends with an error response,
// aRequestId is the id of the transaction that received the error, not of the
// transaction that originally created the refresh.
//
// CSIPRefresh can not be deleted even if the refresh ends (300-699 response).
// User might use the same CSIPRegistrationBinding to register again, and the
// CSIPRefresh would be used again.
// -----------------------------------------------------------------------------
//
TBool
CRegistered::IncomingResponseL(CRegBindingImplementation& aRegistration,
                               CSIPResponseElements* aElements,
		                       TUint32 aRequestId,
				               TUint32 /*aRegistrationId*/,
				               TUint32 aRefreshId,
                               CConnectionCallback& aCallback) const
    {    
    __SIP_ASSERT_LEAVE(aElements, KErrArgument);

    TUint statusCode = aElements->StatusCode();

    if (statusCode >= 300)
        {
        aRegistration.RemoveRegisteredContact();
        aRegistration.ChangeState(iUnregistered);        
        }

    if (statusCode >= 200 && statusCode < 300)
        {
        aRegistration.UpdateRegisteredContactL();
        }

    CSIPClientTransaction* ta = aRegistration.FindTransaction(aRequestId);
    if (ta)
        {
        ta->SetResponseElements(aElements);
        aCallback.Set(CConnectionCallback::EIncomingResponseInRegistration,
                      ta,
                      &aRegistration.Binding());
        return ETrue;
        }

    //If a 2xx is received in registered state, it is a response to an updated
    //REGISTER. Now transaction was not found, meaning application has deleted
    //it, indicating it is not interested on the response or if the response is
    //3xx-6xx it may indicate a refresh has ended.
    if (aRefreshId != 0 && statusCode >= 300)
        {
		ta = aRegistration.CreateClientTransactionL();
		ta->SetRequestId(aRequestId);
		ta->SetResponseElements(aElements);
        aRegistration.UpdateRefreshState(aElements->StatusCode());

        aCallback.Set(CConnectionCallback::EErrorOccuredInRegistration,
                      NULL,
                      &aRegistration.Binding(),
                      NULL,
                      NULL,
                      KErrSIPTerminatedWithResponse,
                      ta);
        return ETrue;
        }
    delete aElements;
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CRegistered::ErrorOccured
// CSIPRefresh can not be deleted even if the refresh ends. Application might
// use the same CSIPRegistrationBinding to register again, and the CSIPRefresh
// would be used again.
// -----------------------------------------------------------------------------
//
TBool CRegistered::ErrorOccured(CRegBindingImplementation& aRegistration,
                                TInt aError,
                                TUint32 aRequestId,
                                CConnectionCallback& aCallback) const
    {
    return aRegistration.HandleError(aCallback,
    								 aError,
    								 aRequestId,
    								 *iUnregistered);
    }

// -----------------------------------------------------------------------------
// CRegistered::RefreshState
// -----------------------------------------------------------------------------
//
CSIPRefresh::TState CRegistered::RefreshState() const
    {
    return CSIPRefresh::EActive;
    }

// -----------------------------------------------------------------------------
// CRegistered::ConnectionLost
// -----------------------------------------------------------------------------
//
void CRegistered::ConnectionLost(CRegBindingImplementation& aRegistration) const
    {    
    aRegistration.ChangeState(iUnregistered);
    }