// Copyright (c) 2008-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: Stores information for a X3P test sequence

// 

//

#include "clbstestx3psessionsequence.h"

/** 2nd Phase constructor

 */

CTestX3PPositionListener* CTestX3PPositionListener::NewL(MTestX3PPositionListener& aObserver, TInt aCallBackId)

	{

	CTestX3PPositionListener* self = new (ELeave) CTestX3PPositionListener(aObserver, aCallBackId);

	return self;

	}

/** Destructor

 */

CTestX3PPositionListener::~CTestX3PPositionListener()

	{

	Cancel();

	}

/** Standard C Constructor

 */

CTestX3PPositionListener::CTestX3PPositionListener(MTestX3PPositionListener& aObserver, TInt aCallBackId)

: CActive(CActive::EPriorityStandard),

iCallBackId(aCallBackId),

iObserver(aObserver)

	{

	CActiveScheduler::Add(this);

	}

/** RunL, calls the X3P test session sequence notifying it of the received event

 */

void CTestX3PPositionListener::RunL()

	{

	iObserver.NotifyX3PEvent(iCallBackId);

	}

void CTestX3PPositionListener::DoCancel()

	{

	}

TInt CTestX3PPositionListener::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}

TRequestStatus& CTestX3PPositionListener::GetStatus()

	{

	SetActive();

	return iStatus;

	}

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

/** 2nd Phase constructor

 */

CTestX3PSessionSequence* CTestX3PSessionSequence::NewL(CLbsTestNgMessageHandler& aNgProxy, MHybridMultipleTestCallBack& aTestCallback,

		TInt aSequenceNum, const TDesC& aConfigFileName, const TDesC& aConfigSection)

	{

	CTestX3PSessionSequence* self = new (ELeave) CTestX3PSessionSequence(aNgProxy, aTestCallback);

	CleanupStack::PushL(self);

	self->ConstructL(aSequenceNum, aConfigFileName, aConfigSection);

	CleanupStack::Pop(self);

	return self;

	}

/** Destructor

 */

CTestX3PSessionSequence::~CTestX3PSessionSequence()

	{

	iTransmitter.Close();

	iServer.Close();

	delete iRefPosListener;

	delete iPosListener;

	}

/** Standard C Constructor

 */

CTestX3PSessionSequence::CTestX3PSessionSequence(CLbsTestNgMessageHandler& aNgProxy, MHybridMultipleTestCallBack& aTestCallback) 

: CTestSessionSequence(aNgProxy, aTestCallback),

iSetup(EFalse)

	{

	}

/** Second phase construction

 */

void CTestX3PSessionSequence::ConstructL(TInt aSequenceNum, const TDesC& aConfigFileName, const TDesC& aConfigSection)

	{

	CTestSessionSequence::ConstructL(aSequenceNum, aConfigFileName, aConfigSection);

	iRefPosListener = CTestX3PPositionListener::NewL(*this, EX3PRefPositionUpdate);

	iPosListener = CTestX3PPositionListener::NewL(*this, EX3PPositionUpdate);

	iTestCallback.LogTestStatement(_L("Type = X3P"));

	iTestCallback.LogTestStatement(_L("-----------------------------------------------------------------------"));

	}

/** Sets up the X3P session

 */

void CTestX3PSessionSequence::SetupTransmit()

	{

	User::LeaveIfError(iServer.Connect());

	TInt err = (iTransmitter.Open(iServer));

	iSetup = ETrue;

	}

/** Makes a Transmit Position (X3P) request

 */

void CTestX3PSessionSequence::TransmitPosition()

	{

	if(!iSetup)

		{

		SetupTransmit();

		}

	_LIT(KThirdParty,"+4407463842101"); 

	const TInt KPriority= 1;

	TLbsTransmitPositionOptions options(TTimeIntervalMicroSeconds(50*1000*1000));

	TRequestStatus& refPosStatus = iRefPosListener->GetStatus();

	TRequestStatus& transPosStatus = iPosListener->GetStatus();

	iTransmitter.SetTransmitOptions(options);

	iTransmitter.TransmitPosition(KThirdParty, KPriority, refPosStatus, iRefPosInfo, transPosStatus, iTransPosInfo);

	}

/* << ProcessStatusUpdate()

 */

void CTestX3PSessionSequence::SendProcessStatusUpdate()

	{

	MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceTransmitThirdParty;

	iNgProxy.ProtocolProxy()->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask);	

	}

/* << ProcessLocationRequest()

 */

void CTestX3PSessionSequence::SendProcessLocationRequest()

	{

	TBool emergency = EFalse;

	MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceTransmitThirdParty;

	TLbsNetPosRequestQuality quality = ArgUtils::QualityAlpha2(); 

	TLbsNetPosRequestMethod method   = ArgUtils::RequestHybridMethod();

	iNgProxy.ProtocolProxy()->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);

	}

/* >> RequestTransmitLocation

 */

void CTestX3PSessionSequence::CheckRequestTransmitLocation(TLbsNetSessionId* aSessionId, TInt aPriority, const TDesC16& aThirdParty)

	{

	//Extract the Session ID and assign it to this sequence

	iSessionId.SetSessionNum(aSessionId->SessionNum());

	iSessionId.SetSessionOwner(aSessionId->SessionOwner());

	//Check the priority is correct

	TInt expectedPriority = 1;

	if(aPriority != expectedPriority)

		{

		iTestCallback.LogTestStatement(_L("Error - Incorrect Priority in RequestTransmitLocation."));

		}

	//Check the Third Party Request ID

	_LIT(KThirdParty,"+4407463842101");

	TBufC16<14> thirdParty(KThirdParty);

	TPtr16 ptr = thirdParty.Des();

	if(ptr.Compare(aThirdParty) != KErrNone)

		{

		iTestCallback.LogTestStatement(_L("Error - Incorrect ThirdParty ID in RequestTransmitLocation."));

		}

	}

/** Handles receiving an X3P event

 */

void CTestX3PSessionSequence::NotifyX3PEvent(TInt aId)

	{

	if(aId == EX3PRefPositionUpdate)

		{

		LogTestStatement(_L("-> X3PReferencePositionUpdate [7000] Sq: %d"), 1, iSequenceId);

		//Check to see whether the event was expected

		if(iStateSequence[iCurrentPosition] == EX3PRefPositionUpdate)

			{

			SignalCallbackIdleStart();

			}

		}

	else if (aId == EX3PPositionUpdate)

		{

		LogTestStatement(_L("-> X3PPositionUpdate [7001] Sq: %d"), 1, iSequenceId);

		//Check to see whether the event was expected

		if(iStateSequence[iCurrentPosition] == EX3PPositionUpdate)

			{

			SignalCallbackIdleStart();

			}

		}

	else

		{

		LogTestStatement(_L("-> Invalid X3P Message Received Sq: %d"), 1, iSequenceId);

		}

	}