/*

* Copyright (c) 2007 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:    Plugin interface implementation.

*

*/

#include "CNSPPluginStub.h"

#include "nspsessionobserver.h"

const TInt KDefaultSessionID		      = 0;

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CNSPPluginStub::CNSPPluginStub

// ---------------------------------------------------------------------------

//

CNSPPluginStub::CNSPPluginStub()

    {

   	iRequestType = CNSPPluginStub::ENone; 

    }

// ---------------------------------------------------------------------------

// CNSPPluginStub::ConstructL

// ---------------------------------------------------------------------------

//

void CNSPPluginStub::ConstructL()

    {

    RDebug::Print(_L("ICEPlugin Dummy: Entry (CNSPPluginStub::ConstructL)"));

    // Create the timer entry 

    iOfferReady = 0;

    iAnswerReady = 0;

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

	iReservStatus = CNSPPlugin::ENSPResourcesNotReserved;

	TCallBack cb( TimerExpire, this );

	iDeltaEntry.Set( cb );

	RDebug::Print(_L("ICEPlugin Dummy: Exit (CNSPPluginStub::ConstructL)"));

	}

// ---------------------------------------------------------------------------

// CNSPPluginStub::NewL

// ---------------------------------------------------------------------------

//

CNSPPluginStub* CNSPPluginStub::NewL()

    {

    CNSPPluginStub* self = new( ELeave ) CNSPPluginStub;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CNSPPluginStub::~CNSPPluginStub

// ---------------------------------------------------------------------------

//

CNSPPluginStub::~CNSPPluginStub() 

    {

	delete iDTimer;

	}

// ---------------------------------------------------------------------------

// CNSPPluginStub::NewSessionL

// ---------------------------------------------------------------------------

//

TUint CNSPPluginStub::NewSessionL( MNSPSessionObserver& aSessionObserver,

                                  TUint32 /*aIapId*/,

                                  const TDesC8& /*aDomain*/,

                                  TUint /*aProtocol*/ )

    {

	RDebug::Print(_L("ICEPlugin Dummy: Entry (CNSPPluginStub::NewSessionL)"));

	iDelay = 50000;

   	iSessionOb = &aSessionObserver;

	iDTimer->Queue( iDelay, iDeltaEntry );

	RDebug::Print(_L("ICEPlugin Dummy: Exit (CNSPPluginStub::NewSessionL)"));

	// Set the timer to get fired for the Initialized Event

	return KDefaultSessionID;

    }

// ---------------------------------------------------------------------------

// CNSPPluginStub::CloseSessionL

// ---------------------------------------------------------------------------

//

void CNSPPluginStub::CloseSessionL( TUint /*aSessionId*/ )

    {

   	iSessionId = 0; 

    }

// ---------------------------------------------------------------------------

// CNSPPluginStub::CreateOfferL

// ---------------------------------------------------------------------------

//

TNatReturnStatus CNSPPluginStub::CreateOfferL( TUint aSessionId, CSdpDocument*& aOffer)

    {

    RDebug::Print(_L("ICEPlugin Dummy: Entry (CNSPPluginStub::CreateOfferL)"));   

	iRequestType = CNSPPluginStub::ECreateOffer;  

    User::LeaveIfNull( &aOffer );

    iSessionId = aSessionId; 

    iReservStatus =  CNSPPlugin::ENSPResourcesReserved;;

    iOffer = aOffer;

    iDelay = iDelay + (iDelay*2);

    iDTimer->Queue( iDelay, iDeltaEntry );

    RDebug::Print(_L("ICEPlugin Dummy: Exit (CNSPPluginStub::CreateOfferL)"));

    return KNatAsync;             

    }

// ---------------------------------------------------------------------------

// CNSPPluginStub::ResolveL

// ---------------------------------------------------------------------------

//

TNatReturnStatus CNSPPluginStub::ResolveL( TUint aSessionId,

                              CSdpDocument*& aOffer,

                              CSdpDocument*& aAnswer )

    {

    RDebug::Print(_L("ICEPlugin Dummy: Entry (CNSPPluginStub::ResolveL)"));   

    iRequestType = CNSPPluginStub::EResolve; 

    User::LeaveIfNull( &aOffer );

    User::LeaveIfNull( &aAnswer ); 

    iSessionId = aSessionId;

  	iOffer = aOffer;

  	iAnswer = aAnswer;

  	iDelay = iDelay + iDelay;

  	iDTimer->Queue( iDelay, iDeltaEntry );

  	RDebug::Print(_L("ICEPlugin Dummy: Exit (CNSPPluginStub::ResolveL)"));

  	return KNatAsync;

    }

// ---------------------------------------------------------------------------

// CNSPPluginStub::DecodeAnswerL

// ---------------------------------------------------------------------------

//

TNatReturnStatus CNSPPluginStub::DecodeAnswerL( TUint aSessionId, CSdpDocument*& aAnswer )

    {

    RDebug::Print(_L("ICEPlugin Dummy: Entry (CNSPPluginStub::DecodeAnswerL)"));   

    iRequestType = CNSPPluginStub::EDecodeAnswer;

    User::LeaveIfNull(&aAnswer);

    iSessionId = aSessionId;

	iAnswer = aAnswer;

    iDelay = iDelay + iDelay;

    iDTimer->Queue( iDelay, iDeltaEntry );

    RDebug::Print(_L("ICEPlugin Dummy: Exit (CNSPPluginStub::DecodeAnswerL)"));

    return KNatAsync;

    }

// ---------------------------------------------------------------------------

// CNSPPluginStub::UpdateL

// ---------------------------------------------------------------------------

//

void CNSPPluginStub::UpdateL( TUint aSessionId, CSdpDocument*& aOffer )

    {

    RDebug::Print(_L("ICEPlugin Dummy: Entry (CNSPPluginStub::UpdateL)"));   

    iRequestType = CNSPPluginStub::EResolve; 

    User::LeaveIfNull( &aOffer );

	iSessionId = aSessionId;

	iOffer = aOffer;

	RDebug::Print(_L("ICEPlugin Dummy: Exit (CNSPPluginStub::UpdateL)"));

    }

// ---------------------------------------------------------------------------

// CNSPPluginStub::RestartL

// ---------------------------------------------------------------------------

TNatReturnStatus CNSPPluginStub::RestartL( TUint aSessionId )

	{

	RDebug::Print(_L("ICEPlugin Dummy: Entry (CNSPPluginStub::RestartL)"));   

	iSessionId = aSessionId;	

	RDebug::Print(_L("ICEPlugin Dummy: Exit (CNSPPluginStub::RestartL)"));

	return KNatAsync;	

	}

// ---------------------------------------------------------------------------

// CNSPPluginStub::GetSessionParam

// ---------------------------------------------------------------------------

 TInt CNSPPluginStub::GetSessionParam( TUint /*aSessionId*/, 

                       TNSPSessionParamKey /*aParamKey*/ )

 	{

 	RDebug::Print(_L("ICEPlugin Dummy: Entry (CNSPPluginStub::GetSessionParam)"));   

	RDebug::Print(_L("ICEPlugin Dummy: Exit (CNSPPluginStub::GetSessionParam)"));   

	return iReservStatus;

 	}

// -----------------------------------------------------------------------------

// CNSPPluginStub::TimerExpire

// -----------------------------------------------------------------------------

//

TInt CNSPPluginStub::TimerExpire( TAny *aSelf )

    { 

    CNSPPluginStub* me = static_cast<CNSPPluginStub *>( aSelf );

    if ( me->iInitialized == 0)

    	{

    	RDebug::Print(_L("ICEPlugin Dummy: (Plugin->Initialized)"));   

    	me->iInitialized = 1;	

		me->iSessionOb->Initialized(0);

		}

	else if ( me->iOfferReady == 1 )

		{

		RDebug::Print(_L("ICEPlugin Dummy: (Plugin->OfferReady)"));   

		me->iOfferReady = 0;

		me->iReservStatus =  CNSPPlugin::ENSPResourcesReserved;;

		me->iSessionOb->OfferReady( KDefaultSessionID, me->iOffer );

		}

	//TBD: For Future Use when Re-Invite for UpdateSDP is supported

	/*	

	else if ( me->iAnswerReady == 1 )

		{

		RDebug::Print(_L("ICEPlugin Dummy: (Plugin->OfferReady)"));   

		me->iOfferReady = 0;

		me->iSessionOb->UpdateSdp( KDefaultSessionID, me->iOffer );	

		}

	*/

	else 

		{ 

		switch ( me->iRequestType )

		{

		case ECreateOffer:

            {

            RDebug::Print(_L("ICEPlugin Dummy: (Plugin->OfferReady)"));   

            me->iSessionOb->OfferReady(KDefaultSessionID, me->iOffer);

            break;

            }

		case EResolve:

            {

            RDebug::Print(_L("ICEPlugin Dummy: (Plugin->AnswerReady)"));   

            me->iSessionOb->AnswerReady(KDefaultSessionID, me->iAnswer);

            me->iOfferReady = 1;

            me->iDelay = me->iDelay + me->iDelay;

            me->iDTimer->Queue( me->iDelay*2, me->iDeltaEntry );

            break;

            }

		case EDecodeAnswer:

            {

            RDebug::Print(_L("ICEPlugin Dummy: (Plugin->AnswerReady)"));   

			me->iAnswerReady = 1;

			me->iSessionOb->AnswerReady( KDefaultSessionID, me->iAnswer );

			//TBD: For Future Use when Re-Invite for UpdateSDP is supported

			/*

			me->iDelay = me->iDelay + me->iDelay;

            me->iDTimer->Queue( me->iDelay*50, me->iDeltaEntry );

            */

			break;

            }

        default:

            {

            //NOP

            break;

            }

		}

		}

    return KErrNone;

    }

// end of file