/*

* Copyright (c) 2004 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:  Implementation.

*

*/

#include "CTcSIPConnectionContainer.h"

#include "TTcSIPReceived.h"

#include "CTcSIPContext.h"

#include "SipConstants.h"

#include "TesterConstants.h"

#include "ErrorHandling.h"

// SIP stack includes

#include <sip.h>

#include <sipconnection.h>

#include <sipdialog.h>

#include <sipdialogassocbase.h>

#include <sipheaderbase.h>

#include <sipcseqheader.h>

#include <sipextensionheader.h>

#include <siprefresh.h>

#include <sipregistrationbinding.h>

#include <sipresponseelements.h>

#include <sipclienttransaction.h>

#include <sipmessageelements.h>

CTcSIPConnectionContainer* CTcSIPConnectionContainer::NewL(

													CTcSIPContext& aContext,

													const TDesC8& aIAPName )

	{

	CTcSIPConnectionContainer* self =

						new( ELeave ) CTcSIPConnectionContainer( aContext,

																 aIAPName );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

CTcSIPConnectionContainer::~CTcSIPConnectionContainer()

	{

	delete iSipConnection;

	delete iTimer;

	iReceiveQueue.Reset();

	}

CTcSIPConnectionContainer::CTcSIPConnectionContainer( CTcSIPContext& aContext,

													  const TDesC8& aIAPName )

	: iContext( aContext ), iReceiveQueue( 1 ), iIAPName( aIAPName )

	{

	}

void CTcSIPConnectionContainer::ConstructL()

	{

	iTimer = CDeltaTimer::NewL( CActive::EPriorityStandard );

	TCallBack cb( ReceiveTimeout, this );

	iReceiveTimeout.Set( cb );

	TInt iapId = iContext.IAPIdL( iIAPName );

	iSipConnection = CSIPConnection::NewL( iContext.SIP(), iapId, *this );

	// SIPConnection doesn't call the callback function if there already

	// is a connection (e.g. from ProfileServer)

	if( iSipConnection->State() == CSIPConnection::EInit )

		{

		iActiveWait.Start();

		}

	}

//

// -- CSIPConnection notifiers ------------------------------------------------

//

// Note that adding an object by-reference to the registry does NOT transfer

// ownership. Adding by-pointer does transfer ownership, however.

// Most/all SIP objects should be in the registry at this stage anyway,

// just make sure that's the case.

void CTcSIPConnectionContainer::IncomingRequest(

										CSIPServerTransaction* aTransaction )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		TTcSIPReceived received;

		received.Set( aTransaction );

		received.SetEvent( TTcSIPReceived::EIncomingRequest );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::IncomingRequest(

										CSIPServerTransaction* aTransaction,

										CSIPDialog& aDialog )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		iContext.Registry().AddObjectL( aDialog );

		TTcSIPReceived received;

		received.Set( aTransaction );

		received.Set( &aDialog );

		received.SetEvent( TTcSIPReceived::EIncomingRequest );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::IncomingResponse(

										CSIPClientTransaction& aTransaction )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.SetEvent( TTcSIPReceived::EIncomingResponse );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::IncomingResponse(

										CSIPClientTransaction& aTransaction,

										CSIPDialogAssocBase& aDialogAssoc )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		iContext.Registry().AddObjectL( aDialogAssoc );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.Set( &aDialogAssoc );

		received.SetEvent( TTcSIPReceived::EIncomingResponse );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::IncomingResponse(

										CSIPClientTransaction& aTransaction,

										CSIPInviteDialogAssoc* aDialogAssoc )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		iContext.Registry().AddObjectL( aDialogAssoc );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.Set( aDialogAssoc );

		received.SetEvent( TTcSIPReceived::EIncomingResponse );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::IncomingResponse(

										CSIPClientTransaction& aTransaction,

										CSIPRegistrationBinding& aRegistration )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		iContext.Registry().AddObjectL( aRegistration );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.Set( &aRegistration );

		received.SetEvent( TTcSIPReceived::EIncomingResponse );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::ErrorOccured(

										TInt aError,

										CSIPTransactionBase& aTransaction )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.SetError( aError );

		received.SetEvent( TTcSIPReceived::EErrorOccured );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::ErrorOccured( TInt aError,

										CSIPClientTransaction& aTransaction,

										CSIPRegistrationBinding& aRegistration )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		iContext.Registry().AddObjectL( aRegistration );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.Set( &aRegistration );

		received.SetError( aError );

		received.SetEvent( TTcSIPReceived::EErrorOccured );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::ErrorOccured( TInt aError,

										CSIPTransactionBase& aTransaction,

										CSIPDialogAssocBase& aDialogAssoc )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		iContext.Registry().AddObjectL( aDialogAssoc );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.Set( &aDialogAssoc );

		received.SetError( aError );

		received.SetEvent( TTcSIPReceived::EErrorOccured );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::ErrorOccured(

										TInt aError,

										CSIPRefresh& aSIPRefresh )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aSIPRefresh );

		TTcSIPReceived received;

		received.Set( &aSIPRefresh );

		received.SetError( aError );

		received.SetEvent( TTcSIPReceived::EErrorOccured );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::ErrorOccured(

										TInt aError,

										CSIPRegistrationBinding& aRegistration )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aRegistration );

		TTcSIPReceived received;

		received.Set( &aRegistration );

		received.SetError( aError );

		received.SetEvent( TTcSIPReceived::EErrorOccured );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::ErrorOccured(

										TInt aError,

										CSIPDialogAssocBase& aDialogAssoc )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aDialogAssoc );

		TTcSIPReceived received;

		received.Set( &aDialogAssoc );

		received.SetError( aError );

		received.SetEvent( TTcSIPReceived::EErrorOccured );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::InviteCompleted(

										CSIPClientTransaction& aTransaction )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( aTransaction );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.SetEvent( TTcSIPReceived::EInviteCompleted );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::InviteCanceled( 

										CSIPServerTransaction& aTransaction )

	{

	TRAPD( err, {

		iContext.Registry().AddObjectL( &aTransaction );

		TTcSIPReceived received;

		received.Set( &aTransaction );

		received.SetError( KSIPErrInviteCanceled );

		received.SetEvent( TTcSIPReceived::EInviteCanceled );

		QueueReceivedL( received );

		} )

	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );

	}

void CTcSIPConnectionContainer::ConnectionStateChanged(

										CSIPConnection::TState aState )

	{

	iConnectionState = aState;

	if( iActiveWait.IsStarted() )

		{

		iActiveWait.AsyncStop();

		}

	}

//

// -- Public functions --------------------------------------------------------

//

TTcSIPReceived CTcSIPConnectionContainer::ReceivedItemL( TInt aTimeout )

	{

	if( iReceiveQueue.Count() == 0 )

		{

		// wait for items to arrive

		iTimer->Queue( aTimeout * KSecondAsMicros, iReceiveTimeout );

		iActiveWait.Start();

		}

	// Is the queue still empty ? (i.e. timeout occurred)

	if( iReceiveQueue.Count() == 0 )

		{

		User::Leave( KErrTimedOut );

		}

	// Get the first (oldest) item from the array

	TTcSIPReceived item = iReceiveQueue[ 0 ];

	// ..and remove it from the array

	iReceiveQueue.Delete( 0 );

	iReceiveQueue.Compress();

	return item;

	}

//

// -- Internal utility functions ----------------------------------------------

//

void CTcSIPConnectionContainer::QueueReceivedL( TTcSIPReceived& aItem )

	{

	iReceiveQueue.AppendL( aItem );

	if( iActiveWait.IsStarted() )

		{

		iTimer->Remove( iReceiveTimeout );

		iActiveWait.AsyncStop();

		}

	}

TInt CTcSIPConnectionContainer::ReceiveTimeout( TAny* aSelf )

	{

	CTcSIPConnectionContainer& self =

				*reinterpret_cast< CTcSIPConnectionContainer* >( aSelf );

	if( self.iActiveWait.IsStarted() )

		{

		self.iActiveWait.AsyncStop();

		}

	return KErrNone;

	}