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



#include <uri8.h>
#include "sipdefs.h"
#include "sipregistrationbinding.h"
#include "RegBindingImplementation.h"
#include "sipclienttransaction.h"
#include "sipmessageelements.h"
#include "sipcontactheader.h"
#include "sipstrings.h"
#include "sipstrconsts.h"


#ifdef CPPUNIT_TEST

#include "TestCleanupStack.h"

#undef EXPORT_C
#define EXPORT_C

#endif


// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRegistrationBinding*
CSIPRegistrationBinding::NewL(CSIPConnection& aConnection,
					   		  CSIPToHeader* aAor,
					   		  CSIPContactHeader* aContact,
					   		  CSIPRefresh* aRefresh,
					   		  CSIPRouteHeader* aOutboundProxy,
					   		  CUri8* aRemoteUri,
                       		  CSIPFromHeader* aFrom)
    {
    CSIPRegistrationBinding* self =
    	CSIPRegistrationBinding::NewLC(aConnection,
					                   aAor,                                                     
                                       aContact,
                                       aRefresh,
					                   aOutboundProxy,
                                       aRemoteUri,
                                       aFrom);
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRegistrationBinding*
CSIPRegistrationBinding::NewLC(CSIPConnection& aConnection,
							   CSIPToHeader* aAor,
							   CSIPContactHeader* aContact,
							   CSIPRefresh* aRefresh,
							   CSIPRouteHeader* aOutboundProxy,
							   CUri8* aRemoteUri,
                        	   CSIPFromHeader* aFrom)
    {
    __ASSERT_ALWAYS(aAor && aContact, User::Leave(KErrArgument));

    if (aContact->HasParam(SIPStrings::StringF(SipStrConsts::EExpires)))
        {        
        TUint expires = aContact->ExpiresParameter();
        __ASSERT_ALWAYS(expires >= KSIPMinExpirationValue,
        			    User::Leave(KErrArgument));
        }

    CSIPRegistrationBinding* self =
    	new (ELeave) CSIPRegistrationBinding();
    CleanupStack::PushL(self);
    self->ConstructL(aConnection,
    				 aAor,
                     aContact,
                     aRefresh,
                     aOutboundProxy,
                     aRemoteUri,
                     aFrom);
    return self;
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::CSIPRegistrationBinding
// -----------------------------------------------------------------------------
//
CSIPRegistrationBinding::CSIPRegistrationBinding()
    {
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::ConstructL
// aAor and aContact have been checked in NewLC so they aren't checked again
// -----------------------------------------------------------------------------
//
void CSIPRegistrationBinding::ConstructL(CSIPConnection& aConnection,
										 CSIPToHeader* aAor,								
								  		 CSIPContactHeader* aContact,                                  
							  	  		 CSIPRefresh* aRefresh,
								  		 CSIPRouteHeader* aOutboundProxy,
								  		 CUri8* aRemoteUri,
                                  		 CSIPFromHeader* aFrom)
    {    
    iImplementation = CRegBindingImplementation::NewL(*this,
    												  aConnection,
    												  aAor,
    												  aContact,
    												  aRefresh,
    												  aOutboundProxy,
    												  aRemoteUri,
    												  aFrom);
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::~CSIPRegistrationBinding
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRegistrationBinding::~CSIPRegistrationBinding()
    {
    delete iImplementation;    
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::IsContextActive
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPRegistrationBinding::IsContextActive() const
    {
    __TEST_INVARIANT;
	return iImplementation->IsContextActive();	
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::ContextId
// -----------------------------------------------------------------------------
//
EXPORT_C TUint32 CSIPRegistrationBinding::ContextId() const
    {
    __TEST_INVARIANT;
    return iImplementation->ContextId();    
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::RegisterL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPRegistrationBinding::RegisterL(CSIPMessageElements* aElements)
    {
    __TEST_INVARIANT;
    return iImplementation->RegisterL(aElements);
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::DeregisterL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPRegistrationBinding::DeregisterL(CSIPMessageElements* aElements)
    {
    __TEST_INVARIANT;
    return iImplementation->DeregisterL(aElements);
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::UpdateL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPRegistrationBinding::UpdateL(CSIPMessageElements* aElements)
    {
    __TEST_INVARIANT;
    __ASSERT_ALWAYS(aElements, User::Leave(KErrArgument));

	return iImplementation->UpdateL(aElements);
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::UpdateL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPClientTransaction*
CSIPRegistrationBinding::UpdateL(TUint aExpirationValue,
                          		 CSIPMessageElements* aElements)
    {
    __TEST_INVARIANT;
    __ASSERT_ALWAYS(aExpirationValue >= KSIPMinExpirationValue,
    				User::Leave(KErrArgument));

    return iImplementation->UpdateL(aElements, &aExpirationValue);    
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::SetOutboundProxyL
// -----------------------------------------------------------------------------
//
EXPORT_C void
CSIPRegistrationBinding::SetOutboundProxyL(CSIPRouteHeader* aOutboundProxy)
    {
    __TEST_INVARIANT;

    iImplementation->SetOutboundProxyL(aOutboundProxy);
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::Aor
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPToHeader& CSIPRegistrationBinding::Aor() const
    {
    __TEST_INVARIANT;
    return iImplementation->Aor();
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::ContactHeader
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPContactHeader& CSIPRegistrationBinding::ContactHeader() const
    {
    __TEST_INVARIANT;
    return iImplementation->ContactHeader();    
    }
    
// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::ContactHeader
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPContactHeader& CSIPRegistrationBinding::ContactHeader()
    {
    __TEST_INVARIANT;
    return iImplementation->ContactHeader();    
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::OutboundProxy
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPRouteHeader* CSIPRegistrationBinding::OutboundProxy() const
    {
    __TEST_INVARIANT;
    return iImplementation->OutboundProxy();    
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::SIPRefresh
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPRefresh* CSIPRegistrationBinding::SIPRefresh() const
    {
    __TEST_INVARIANT;
    return iImplementation->SIPRefresh();    
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::SIPRefresh
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRefresh* CSIPRegistrationBinding::SIPRefresh()
    {
    __TEST_INVARIANT;
    return iImplementation->SIPRefresh();    
    }
    
// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::Connection
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPConnection* CSIPRegistrationBinding::Connection()
    {
    __TEST_INVARIANT;
    return iImplementation->Connection();    
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::Connection
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPConnection* CSIPRegistrationBinding::Connection() const
    {
    __TEST_INVARIANT;
    return iImplementation->Connection();    
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::operator==
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPRegistrationBinding::operator==(
    const CSIPRegistrationBinding& aRegistration) const
    {
    __TEST_INVARIANT;    
    return *iImplementation == *aRegistration.iImplementation;
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::RegisteredContact
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPContactHeader* 
    CSIPRegistrationBinding::RegisteredContact() const
    {
    __TEST_INVARIANT;
    return iImplementation->RegisteredContact();
    }

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::SetProperty
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CSIPRegistrationBinding::SetProperty(TUint32 aProperty,TBool aValue)
	{
	__TEST_INVARIANT;
	TRAPD(err, iImplementation->SetPropertyL(aProperty,aValue));
	return err;
	}

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::Implementation
// -----------------------------------------------------------------------------
//
CRegBindingImplementation& CSIPRegistrationBinding::Implementation()
	{
	__TEST_INVARIANT;
	return *iImplementation;
	}

// -----------------------------------------------------------------------------
// CSIPRegistrationBinding::__DbgTestInvariant
// -----------------------------------------------------------------------------
//

void CSIPRegistrationBinding::__DbgTestInvariant() const
	{
    if (!iImplementation)
        {
		User::Invariant();
		}
	}