// 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:

// This file provides the class implementation of the ECOM plug-in 

// interface for the LBS test Network Protocol Module.

// 

//

#include "lbssupltestmodule.h"

#include "lbssuplsocketlistener.h"

#include <ecom/implementationproxy.h>

//const TUint32 KInetAddr1 = INET_ADDR(209,172,70,68);//SiRF server

const TUint32 KInetAddr2 = INET_ADDR(66,230,192,56);//SiRF sever

const TUint32 KLoopBackAddr = INET_ADDR(127,0,0,1);//Used by SiRF in session ID of SUPL RESPONSE -proxy mode-

const TUint KSuplPort =  7276; // standard SUPL TCP port.

const TInt KNetworkTimeout = 45000000;

const TInt KProtocolTimeout = 50000000;

const TInt KMaxTxBufferSize = 2048; // 2k Max size of SUPL messages sent

const TInt KMaxRxBufferSize = 8192; // 8k Max size of SUPL messages received

// --------------------- SUPL TEST MODULE (ECom plug-in) --------------------------

/** The unique ID of this plug-in interface.

This corresponds to the interface UID specified in the .rss file

for this SUPL test module.

*/

const TInt KPluginUidValue = 0x1028225B;

CSuplProtocolModule* CSuplProtocolModule::NewL(TAny* aInitParams)

	{

	CSuplProtocolModule* self=new(ELeave) CSuplProtocolModule(aInitParams);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CSuplProtocolModule::~CSuplProtocolModule()

	{

	iSocketServerSession.Close();

	}

CSuplProtocolModule::CSuplProtocolModule(TAny* aInitParams): 

	iObserver(REINTERPRET_CAST(

	          TAssistanceDataSourceModuleConstructionParams*,

	          aInitParams)->iAssistanceDataSourceObserver),

	iNextSessionNumber(0)

	{

	}

void CSuplProtocolModule::ConstructL()

	{

	// Open channel to Socket Server

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

	}

CAssistanceDataSourceBase* CSuplProtocolModule::NewDataSourceL()

	{

	// Create a new number for the session

	if (iNextSessionNumber == 1000)

	{

		iNextSessionNumber = 0;

	}

	iNextSessionNumber++;

	return CSuplProtocolSession::NewL(iObserver, iSocketServerSession, iNextSessionNumber);

	}

/** Defines the plug-in interface implementation UIDs, required by ECOM.

*/

const TImplementationProxy ImplementationTable[] = 

    {

    IMPLEMENTATION_PROXY_ENTRY(KPluginUidValue, CSuplProtocolModule::NewL)

    };

/** Exported function for ECOM to retrieve implementations table

*/

EXPORT_C 

const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

//--------------------- SUPL Session ---------------------------------------------------------

CSuplProtocolSession::CSuplProtocolSession(MLbsAssistanceDataSourceObserver& aObserver, const TInt16& aSessionNumber): 

	CActive(EPriorityStandard),

    iObserver(&aObserver),

    iBuilderSet(NULL),

    iSessionNumber(aSessionNumber)

	{

	// Attach to active scheduler

	//

	CActiveScheduler::Add(this);

	iAddress.SetPort(KSuplPort);

	iAddress.SetAddress(KInetAddr2);

	}

void CSuplProtocolSession::ConstructL(RSocketServ& aSocketServer)

	{

	iTxBuf.CreateMaxL(KMaxTxBufferSize);

	iRxBuf.CreateMaxL(KMaxRxBufferSize);

	// Open a TCP socket

	User::LeaveIfError(iSocket.Open(aSocketServer, KAfInet, KSockStream, KProtocolInetTcp));

    // Set SUPL port in socket

    //

    iSocket.SetLocalPort(KSuplPort);

	// Create a socket listener for SUPL messages

	iSuplSocketListener = CSuplSocketListener::NewL(iSocket, iRxBuf);

	// Create the timer

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

	}

CSuplProtocolSession::~CSuplProtocolSession()

	{

		Cancel();

		iTxBuf.Close();

		iRxBuf.Close();

		delete iTimer;

		delete iSuplSocketListener;

		iSocket.Close();

	}

/**

GetAssistanceData() Called by Network Simulator to request assitance data from the remote

server.

@parameter aBuilderSet. The CSuplProtocolSession will set the fields of this builder with

			the assistance data.

*/

void CSuplProtocolSession::GetAssistanceData(RLbsAssistanceDataBuilderSet& aBuilderSet, const TLbsAssistanceDataGroup& aAssistanceDataFilter, const TCoordinate& aPosition)

	{

	iBuilderSet = &aBuilderSet;

	iAssistanceDataFilter = aAssistanceDataFilter;

	iPosition = aPosition;

    // Validate parameters

	if(aAssistanceDataFilter == 0)

		{

		iObserver->DataSourceNotification(KErrArgument);

		}

	else

		{

		// Set the correct state and force a transition of the state machine

		if(iSessionState == EConnectedAwaitingRequest)

			{

			// Transition out of wait state

			iSessionState = EAssistanceDataRequested;

			}

		else

			{

			// If in the process of collecting assistance data, cancel previous request and

			// start over.

			// Do not notify NetSim that previous assistance data retrieval won't be completed

			// (it should know)

			CancelGetAssistanceData();

			// Flag that a request is pending

			iAssistanceDataRequestPending = true;

			}

		// Transition out of inactive states (EIdle and EConnectedAwaitingState)

		if(!IsActive())

			{

			PrepareSelfTransition();

			}

		}

	}

CSuplProtocolSession* CSuplProtocolSession::NewL(MLbsAssistanceDataSourceObserver& aObserver,RSocketServ& aSocketServer, const TInt16& aSessionNumber)

	{

	CSuplProtocolSession* self= new(ELeave) CSuplProtocolSession(aObserver,aSessionNumber);

	CleanupStack::PushL(self);

	self->ConstructL(aSocketServer);

	CleanupStack::Pop();

	return self;

	}

void CSuplProtocolSession::RunL()

	{

	iTimer->Cancel();

	// Deal with errors in socket operations

	if (iStatus != KErrNone)

	{

		if ((iSessionState == EConnectingToRemoteServer) && (!iAssistanceDataRequestPending))

			{

			// Disconnect without reporting to NetSim

			iSessionState = EDisconnectingFromServer;

			}

		else if ((iAssistanceDataRequestPending) && (iStatus == KErrCancel))

			{

			// Assume the cancellation has been due to a new request from NetSim

			// Start over without reporting to NetSim.

			iSessionState = EConnectingToRemoteServer;

			}

		else

			{

			// start disconnection and report to NetSim

			iSessionState = ENetworkTimeout;

			}

	}

	switch(iSessionState)

		{

		case EIdle:

			ConnectToRemoteServer();	

			break;

		case EConnectingToRemoteServer:

			TransitionAccordingToRequestAvailability();

			break;

		case EConnectedAwaitingRequest:

			// Nothing to be done in this state.

			// This state is left when the Network

			// Simulator requests assistance data

			// (see GetAssistanceData())

			break;

		case EAssistanceDataRequested:

			iAssistanceDataRequestPending = EFalse;

			iSessionState = ESendingSuplStart;

			SendSuplMessageL(ESuplStart);

			break;

		case ESendingSuplStart:

			// SuplStart sent. Wait for SuplResponse

			iSessionState = EAwaitingSuplResponse;

			ReadSuplMessage();

			break;

		case EAwaitingSuplResponse:

		    iSessionState = ESuplResponseAvailable;

			DecodeSuplMessageL(ESuplResponse); //May set error state

		    break;

		case ESuplResponseAvailable:

			iSessionState = ESendingSuplPosInit;

			SendSuplMessageL(ESuplPosInit);	

			break;

		case ESendingSuplPosInit:

			iSessionState = EAwaitingSuplPos;

			ReadSuplMessage();

			break;

		case EAwaitingSuplPos:

			iSessionState = ESuplPosAvailable;

			DecodeSuplMessageL(ESuplPos);	//May set error state

			break;

		case ESuplPosAvailable:

		    iSessionState = ERrcPayloadDecodeComplete;

			DecodeRRCPayloadL();

			PrepareSelfTransition();

			break;

		case ERrcPayloadDecodeComplete:

			iSessionState = EEndingSession;

			// Notify succesful exit to NetSim

			iObserver->DataSourceNotification(KErrNone);

			PrepareSelfTransition();

			break;

		case EProtocolError:

			//Unexpected message. Notify unsuccesfull exit to NetSim

			iObserver->DataSourceNotification(KErrCancel);

			iAssistanceDataRequestPending = EFalse;

			iSessionState = EDisconnectingFromServer;

			PrepareSelfTransition();

			break;

		case ENetworkTimeout:

			// Report to NetSim that something went wrong

			iObserver->DataSourceNotification(iStatus.Int());

			iAssistanceDataRequestPending = EFalse;

			iSessionState = EDisconnectingFromServer;

			PrepareSelfTransition();

			break;

		case EDisconnectingFromServer:

			iSessionState = EIdle;

			iSocket.Shutdown(RSocket::ENormal,iStatus);

			SetActive();

			break;

		case EEndingSession:

			iSessionState = ESuplEndSent;

			SendSuplMessageL(ESuplEnd);

			break;

		case ESuplEndSent:

 			iSessionState = EConnectingToRemoteServer;

			ReadSuplMessage();

			break;

		default:

			Cancel();

			User::Leave(KErrGeneral);

			break;

		}

	}

/**

CancelGetAssistanceData. Cancels a previous request

for Assistance Data and starts actions to bring the state

machine to EConnectedAwaitingRequest again, where a new

request for assistance data can be serviced.

If the session had been started with the remote server 

to obtain Assistance Data, the session is first brought

down and the state machine will autonomously reconnect and

move on to EConnectedAwaitingRequest state.

The Nework Simulator will not receive a notification of

cancellation of the previous request for assistance data.

Note this cancelling method is unrelated to

CActive::Cancel()/DoCancel(). The state machine will remain

active and method RunL is expected to be called after this

method completes (unlike DoCancel()).

@return Symbian error code. KErrNone if OK.

*/

void CSuplProtocolSession::CancelGetAssistanceData()

	{

	iTimer->Cancel();

	// Do not service pending requests

	iAssistanceDataRequestPending = false;

	switch (iSessionState)

		{

		case EIdle:

		case EConnectingToRemoteServer:

		case EConnectedAwaitingRequest:

		case EDisconnectingFromServer:

		case ENetworkTimeout:

		case EProtocolError:

		case EEndingSession:

		// nothing to do (session not getting assistance data)

		break;

		case EAssistanceDataRequested:

		// Session not started with remote server yet.

		// RunL will be called shortly as a self transition

		// was prepared when this state was entered.

		// Put the state machine in a position of

		// transitioning towards EConnectedAwaitingRequest state.

		iSessionState = EConnectingToRemoteServer;			

		break;

		case ESendingSuplStart:

		case ESendingSuplPosInit:

		// Cancel send operation.

		// RunL will process KErrCancel case,

		// setting the state to EDisconnectingFromServer.

		iSocket.CancelWrite();

		break;

		case EAwaitingSuplResponse:

		case EAwaitingSuplPos:

		case ESuplEndSent:

		// Cancel receive operation

		// RunL will process KErrCancel case,

		// setting the state to EDisconnectingFromServer.

		iSuplSocketListener->Cancel();

		break;

		case ESuplResponseAvailable:

		case ESuplPosAvailable:

		case ERrcPayloadDecodeComplete:

		// These three states have prepared

		// self-transaction. When RunL gets

		// executed, disconnect:

		iSessionState = EDisconnectingFromServer;

		break;

		default:

		// Not a valid state

		User::Invariant();

		break;

		}

	}

TInt CSuplProtocolSession::OnTimerEventL(TAny* aPtr)

	{

	CSuplProtocolSession* aSession = STATIC_CAST(CSuplProtocolSession*,aPtr);

	if (aSession)

		{

		aSession->DoProcessTimeoutL();

		}

	return KErrNone;

	}

void CSuplProtocolSession::DoProcessTimeoutL()

{

	iTimer->Cancel();

	// Cancel async tasks to re-enter RunL with

	// error code KErrCancel

	switch(iSessionState)

	{

		case EConnectingToRemoteServer:

			iSocket.CancelConnect();

			break;

		case ESendingSuplStart:

		case ESendingSuplPosInit:

			iSocket.CancelWrite();

			break;

		case EAwaitingSuplPos:

		case EAwaitingSuplResponse:

			iSuplSocketListener->Cancel();

			break;

		default:

			// No other state should have a timer running

			Cancel();

			User::Leave(KErrGeneral);

			break;

	}

}

void CSuplProtocolSession::CreateSuplStartMessageL()

	{

	CSuplMessageContent* suplMsgContent=CSuplMessageContent::NewLC();

	// Build common part

	suplMsgContent->iMessageChoice=ESuplStart;	

	BuildCommonPartL(suplMsgContent);

	suplMsgContent->iSuplStartContent=CSuplStartContent::NewL();

	// Qop field is optional BUT required for the SiRF server to work with RRC

	TBool qopPresent = ETrue;

	suplMsgContent->iSuplStartContent->iQopPresent=qopPresent;

	// Set capabilities (mandatory)

	suplMsgContent->iSuplStartContent->iSetCapabilitiesContent=CSuplSetCapabilitiesContent::NewL();

	BuildSetCapabilitiesL(suplMsgContent->iSuplStartContent->iSetCapabilitiesContent);

	//LocationId --- CellInfo

	suplMsgContent->iSuplStartContent->iLocationIdContent=CSuplLocationIdContent::NewL();

	suplMsgContent->iSuplStartContent->iLocationIdContent->iCellInfoContent=CSuplCellInfoContent::NewL();

	BuildCellInfoL(suplMsgContent->iSuplStartContent->iLocationIdContent->iCellInfoContent, EGsmCellInformation); // Verify EGsmCellInformation

	suplMsgContent->iSuplStartContent->iLocationIdContent->iLocationStatus= ECurrent; //TSuplLocationStatus

	// QoP

	suplMsgContent->iSuplStartContent->iQoPContent=CSuplQoPContent::NewL();

	suplMsgContent->iSuplStartContent->iQoPContent->iVeraccPresent = EFalse;

	suplMsgContent->iSuplStartContent->iQoPContent->iMaxLocAgePresent = EFalse;

	suplMsgContent->iSuplStartContent->iQoPContent->iDelayPresent = EFalse;

	suplMsgContent->iSuplStartContent->iQoPContent->iHoracc= 20; // Random value !!!

	CSuplMessage* suplMessageEncoder=CSuplMessage::NewLC(*suplMsgContent);

    // Encode message

    iTxBuf.SetLength(0);

	suplMessageEncoder->EncodeL(iTxBuf);

	CleanupStack::PopAndDestroy(suplMessageEncoder);

	CleanupStack::PopAndDestroy(suplMsgContent);

	}

void CSuplProtocolSession::CreateSuplEndMessageL()

	{

	CSuplMessageContent* suplMsgContent=CSuplMessageContent::NewLC();

	// Build common part

	suplMsgContent->iMessageChoice=ESuplEnd;	

	BuildCommonPartL(suplMsgContent);

	suplMsgContent->iSuplEndContent=CSuplEndContent::NewL();

	// Position field should be false

	suplMsgContent->iSuplEndContent->iPositionPresent=EFalse;

	// Status Code field should be false

	suplMsgContent->iSuplEndContent->iStatusCodePresent=EFalse;

	// Ver field should be false

	suplMsgContent->iSuplEndContent->iVerPresent=EFalse;		

	CSuplMessage* suplMessageEncoder=CSuplMessage::NewLC(*suplMsgContent);

    // Encode message

    iTxBuf.SetLength(0);

	suplMessageEncoder->EncodeL(iTxBuf);

	CleanupStack::PopAndDestroy(suplMessageEncoder);

	CleanupStack::PopAndDestroy(suplMsgContent);

	}

void CSuplProtocolSession::CreatePosInitMessageL()

	{

	CSuplMessageContent* suplMsgContent=CSuplMessageContent::NewLC();

	// Build common part

	suplMsgContent->iMessageChoice = ESuplPosInit;

	BuildCommonPartL(suplMsgContent);