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

//

#include "lbsdevloggermacros.h"

#include "lbsnetsimgatewayhandler.h"

#include "lbsnetsimtesthandler.h"

#include "lbsnetsimassistancedataprovider.h"

#include <lbspositioninfo.h>

#include <lbs/lbslocdatasourcegpsbase.h>

#include <lbs/test/lbsnetsimstatus.h>

#include <lbs/test/lbsnetsimtest.h>

#include <e32property.h>

#include <s32mem.h>

TLbsAssistanceDataGroup CLbsNetSimGatewayHandler::iDefaultAssistanceDataMask = EAssistanceDataReferenceTime | EAssistanceDataReferenceLocation | EAssistanceDataNavigationModel;

/**

*/

CLbsNetSimGatewayHandler* CLbsNetSimGatewayHandler::NewL(CLbsNetSimAssistanceDataProvider& aAssistanceDataProvider)

	{

	CLbsNetSimGatewayHandler* self = new(ELeave) CLbsNetSimGatewayHandler(aAssistanceDataProvider);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

*/

CLbsNetSimGatewayHandler::~CLbsNetSimGatewayHandler()

	{

	iMessages.Reset();

	iMeasurementControlLocationAssistanceData.Close();

	}

/**

*/

void CLbsNetSimGatewayHandler::SetTestHandler(CLbsNetSimTestHandler* aTestHandler)

	{

	iTestHandler = aTestHandler;

	}

/**

*/

void CLbsNetSimGatewayHandler::ServiceL(const RMessage2& aMessage)

	{

	TInt function = aMessage.Function();

	if ((iError == KErrNone) ||

	    (function == EGWNotificationMeasurementControlLocation) ||

	    (function == EGWNotificationMeasurementControlLocationCancel) ||

	    (function == EGWNotificationRegisterLcsLocation) ||

	    (function == EGWNotificationRegisterLcsLocationCancel) ||

	    (function == EGWNotificationCancelPrivacy) ||

	    (function == EGWNotificationCancelPrivacyCancel) ||

	    (function == EGWNotificationNetworkGone) ||

	    (function == EGWNotificationNetworkGoneCancel) ||

	    (function == EGWNotificationResetAssistanceData) ||

		(function == EGWNotificationResetAssistanceDataCancel))

		{

		switch (aMessage.Function())

			{

			case EGWRegisterLcsMoLr:

				{

				HandleRegisterLcsMoLrL(aMessage);

				break;

				}

			case EGWMeasurementReportLocation:

				{

				HandleMeasurementReportLocationL(aMessage);

				break;

				}

			case EGWMeasurementReportLocationCancel:

				{

				if (!iMessageMeasurementReportLocation.IsNull())

					{

					iMessageMeasurementReportLocation.Complete(KErrCancel);

					}

				aMessage.Complete(KErrNone);

				break;

				}

			case EGWReleaseLcsMoLr:

				{

				HandleReleaseLcsMoLrL(aMessage);

				break;

				}

			case EGWMeasurementControlFailure:

				{

				HandleMeasurementControlFailureL(aMessage);

				break;

				}

			case EGWRequestMoreAssistanceData:

				{

				HandleRequestMoreAssistanceDataL(aMessage);

				break;

				}

			case EGWNotificationMeasurementControlLocation:

				{

				iNotificationMeasurementControlLocation = aMessage;

				break;

				}

			case EGWNotificationMeasurementControlLocationCancel:

				{

				if (!iNotificationMeasurementControlLocation.IsNull())

					{

					iNotificationMeasurementControlLocation.Complete(KErrCancel);

					}

				break;

				}

			case EGWNotificationRegisterLcsLocation:

				{

				iNotificationRegisterLcsLocation = aMessage;

				break;

				}

			case EGWNotificationRegisterLcsLocationCancel:

				{

				if (!iNotificationRegisterLcsLocation.IsNull())

					{

					iNotificationRegisterLcsLocation.Complete(KErrCancel);

					}

				break;

				}

			case EGWReleaseLcsLocationNotification:

				{

				HandleReleaseLcsLocationNotifcationL(aMessage);

				break;

				}

			case EGWNotificationCancelPrivacy:

				{

				iNotificationCancelPrivacyRequest = aMessage;

				break;

				}

			case EGWNotificationCancelPrivacyCancel:

				{

				if (!iNotificationCancelPrivacyRequest.IsNull())

					{

					iNotificationCancelPrivacyRequest.Complete(KErrCancel);

					}

				break;

				}

			case EGWNotificationNetworkGone:

				{

				iNotificationNetworkGone = aMessage;

				break;

				}

			case EGWNotificationNetworkGoneCancel:

				{

				if (!iNotificationNetworkGone.IsNull())

					{

					iNotificationNetworkGone.Complete(KErrCancel);

					}

				break;

				}

			case EGWNotificationResetAssistanceData:

				{

				iNotificationResetAssistanceData = aMessage;

				break;

				}

			case EGWNotificationResetAssistanceDataCancel:

				{

				if (!iNotificationResetAssistanceData.IsNull())

					{

					iNotificationResetAssistanceData.Complete(KErrCancel);

					}

				break;

				}

			default:

				{

				ASSERT(EFalse);

				User::Leave(KErrNotSupported);

				}

			} // switch

		} // if

	else

		{

		if (!iNotificationMeasurementControlLocation.IsNull() &&

			((function == EGWRegisterLcsMoLr) ||

			(function == EGWRequestMoreAssistanceData)))

			{

			iNotificationMeasurementControlLocation.Complete(iError);

			FinishL();

			}

		else

			{

			aMessage.Complete(iError);

			FinishL();

			}

			if (!iErrorSticky)

				{

				iError = KErrNone;

				} // if

		}

	}

/**

*/

void CLbsNetSimGatewayHandler::Connected()

	{

	LBSLOG(ELogP1, "CLbsNetSimGatewayHandler::Connected()");

	iTestHandler->GatewayConnected();

	}

/**

*/

void CLbsNetSimGatewayHandler::Disconnected()

	{

	LBSLOG(ELogP1, "CLbsNetSimGatewayHandler::Disconnected()");

	// As the server and handlers could possibly be used for a

	// second session reset some internals here

	ResetInternals();

	// Empty Messages

	CTimer::Cancel();

	while (iMessages.Count() > 0)

		{

		TRAP_IGNORE(RunL());

		}

	iTestHandler->GatewayDisconnected();

	// Complete any outstanding messages

	if (!iAssistanceDataToFill.IsNull())

		{

		iAssistanceDataToFill.Complete(KErrDisconnected);

		}

	if (!iMessageReleaseLcsMoLr.IsNull())

		{

		iMessageReleaseLcsMoLr.Complete(KErrDisconnected);

		}

	if (!iMessageMeasurementReportLocation.IsNull())

		{

		iMessageMeasurementReportLocation.Complete(KErrDisconnected);

		}

	if (!iMessageMeasurementControlFailure.IsNull())

		{

		iMessageMeasurementControlFailure.Complete(KErrDisconnected);

		}

	if (!iNotificationMeasurementControlLocation.IsNull())

		{

		iNotificationMeasurementControlLocation.Complete(KErrDisconnected);

		}

	if (!iNotificationRegisterLcsLocation.IsNull())

		{

		iNotificationRegisterLcsLocation.Complete(KErrDisconnected);

		}

	if (!iNotificationCancelPrivacyRequest.IsNull())

		{

		iNotificationCancelPrivacyRequest.Complete(KErrDisconnected);

		}

	if (!iNotificationNetworkGone.IsNull())

		{

		iNotificationNetworkGone.Complete(KErrDisconnected);

		}

	if (!iNotificationResetAssistanceData.IsNull())

		{

		iNotificationResetAssistanceData.Complete(KErrDisconnected);

		}

	}

/**

*/

void CLbsNetSimGatewayHandler::ProcessAssistanceDataL(TInt aError,

													  RLbsAssistanceDataBuilderSet& aAssistanceData,

								   					  TPositionInfo& aPosition,

								   					  TLbsNetPosRequestQuality& aQuality)

	{

	LBSLOG(ELogP1, "CLbsNetSimGatewayHandler::ProcessAssistanceDataL()");

	LBSLOG2(ELogP2, "AssistanceDataError = %d", aError);

	iAssistanceDataError = aError;

	// Write position to message

	TPckg<TPositionInfo> positionPkg(aPosition);

	iNotificationMeasurementControlLocation.WriteL(0, positionPkg, 0);

	// Write quality to message

	TPckg<TLbsNetPosRequestQuality> qualityPkg(aQuality);

	iNotificationMeasurementControlLocation.WriteL(1, qualityPkg, 0);

	// Write assistance data to the message

	HBufC8* buffer = HBufC8::NewLC(RLbsAssistanceDataBuilderSet::MaxExternalizedBufferSize());

	TPtr8 des(buffer->Des());

	RDesWriteStream stream(des);

	CleanupClosePushL(stream);

	aAssistanceData.ExternalizeL(stream);

	stream.CommitL();

	iNotificationMeasurementControlLocation.WriteL(2, des, 0);

	CleanupStack::PopAndDestroy(2, buffer);

	// Fire test notification

	iMeasurementControlLocationAssistanceData.MergeL(aAssistanceData);

	iMeasurementControlLocationPosition = aPosition;

	iMeasurementControlLocationQuality = aQuality;

	// Complete the message

	iGotAssistanceData = ETrue;

	if (!IsActive() &&

		(iMessages.Count() > 0) &&

	    ((iMessages.At(0) == EContinueRegisterLcsMoLr2) ||

		 (iMessages.At(0) == EContinueRequestMoreAssistanceData) ||

		 (iMessages.At(0) == EContinueMtLr)))

		{

		After(0);

		}

	}

/**

*/

void CLbsNetSimGatewayHandler::SetAssistanceDataMask(TLbsAssistanceDataGroup& aMask)

	{

	iAssistanceDataMask = aMask;

	}

/**

*/

void CLbsNetSimGatewayHandler::SetMoreAssistanceDataMask(TLbsAssistanceDataGroup& aMask)

	{

	iMoreAssistanceDataMask = aMask;

	}

/**

*/

void CLbsNetSimGatewayHandler::ClearAssistanceDataMasks()

	{

	iAssistanceDataMask = iDefaultAssistanceDataMask;

	}

/**

*/

void CLbsNetSimGatewayHandler::StartNetworkPrivacyRequestL(TLbsNetPosRequestPrivacy& aType, TLbsExternalRequestInfo& aRequestInfo)

	{

	// Get emergency state

	TBool emergency = EFalse;

	RProperty::Get(TUid::Uid(KLbsNetSimStatus), KLbsEmergencyStatus, emergency);

	if (iState == ENothing)

		{

		// Write args

		TPckg<TLbsExternalRequestInfo>	requestInfoPkg(aRequestInfo);

		iNotificationRegisterLcsLocation.WriteL(0, requestInfoPkg);

		TPckg<TLbsNetPosRequestPrivacy>	requestPrivacyPkg(aType);

		iNotificationRegisterLcsLocation.WriteL(1, requestPrivacyPkg);

		iNotificationRegisterLcsLocation.Complete(KErrNone);

		iState = (emergency) ? EPrivacy_E : EPrivacy;

		}

	else

		{

		if ((iMtLrOverrides) ||

		    (emergency && ((iState != EPrivacy_E) && (iState != EMtLr_E))))

			{

			// Cancel what we are doing and start the MtLr

			iPrivacyType = aType;

			iPrivacyRequest = aRequestInfo;

			Cancel((emergency) ? EPrivacy_E : EPrivacy);

			}

		else

			{

			User::Leave(KErrInUse);

			}

		}

	}

/**

*/

void CLbsNetSimGatewayHandler::CancelNetworkPrivacyRequestL()

	{

	if (iState != ENothing)

		{

	   	if (!iNotificationRegisterLcsLocation.IsNull())

			{

			iNotificationRegisterLcsLocation.Complete(KErrCancel);

			}

		FinishL();

		}

	}

/**

*/

void CLbsNetSimGatewayHandler::StartNetworkLocationRequestL()

	{

	// Get emergency state

	TBool emergency = EFalse;

	RProperty::Get(TUid::Uid(KLbsNetSimStatus), KLbsEmergencyStatus, emergency);

	if (iState == ENothing)

		{

		iGotAssistanceData = EFalse;

		iAssistanceDataProvider.RequestAssistanceDataL(iDefaultAssistanceDataMask);

		AddMessageL(EContinueMtLr);

		iState = (emergency) ? EMtLr_E : EMtLr;

		}

	else

		{

		if ((iMtLrOverrides) ||

		    (emergency && ((iState != EPrivacy_E) && (iState != EMtLr_E))))

			{

			// Cancel what we are doing and start the MtLr

			Cancel((emergency) ? EMtLr_E : EMtLr);

			}

		else

			{

			User::Leave(KErrInUse);

			}

		}

	}

/**

*/

void CLbsNetSimGatewayHandler::CancelNetworkLocationRequestL()

	{

	if (iState != ENothing)

		{

		if (!iNotificationMeasurementControlLocation.IsNull())

			{

			iNotificationMeasurementControlLocation.Complete(KErrCancel);

			}

		FinishL();

		}

	}

void CLbsNetSimGatewayHandler::SendResetAssistanceData(TLbsAssistanceDataGroup aMask)

	{

	TPckg<TLbsAssistanceDataGroup> maskPkg(aMask);

	TInt err = iNotificationResetAssistanceData.Write(0, maskPkg);

	iNotificationResetAssistanceData.Complete(err);

	}

/**

*/

void CLbsNetSimGatewayHandler::RunL()

	{

	if (!iWaitTimeSticky)

		{

		iWaitTime = 0;

		}

	switch (iMessages.At(0))

		{

		case EContinueRegisterLcsMoLr1:

			{

			// Check to see we have a valid destination

			if (CheckDestinationValidity(iRegisterLcsMoLrData->Des()))

				{

				// Notify test handler

				TInt err = iTestHandler->GatewayRegisterLcsMoLr(iRegisterLcsMoLrData->Des());

				if (err == KErrNone)

					{

					// So MoLr or X3P

					if (iRegisterLcsMoLrData->Length() == 0)

						{

						iState = EMoLr;

						}

					else

						{

						iState = EX3P;

						}

					iSubState = EPreMrl;

					iRequestCancelled = EFalse;

					// Regardless of type we do same thing here => kick of request for assitance data

					iGotAssistanceData = EFalse;

					iAssistanceDataProvider.RequestAssistanceDataL(iAssistanceDataMask);

					AddMessageL(EContinueRegisterLcsMoLr2);

					}

				else

					{

					iNotificationMeasurementControlLocation.Complete(err);

					FinishL();

					}

				}

			else

				{

				iNotificationMeasurementControlLocation.Complete(KErrArgument);

				FinishL();

				}

			delete iRegisterLcsMoLrData;

			iRegisterLcsMoLrData = NULL;

			iMessages.Delete(0);

			break;

			}

		case EContinueRegisterLcsMoLr2:

		case EContinueRequestMoreAssistanceData:

		case EContinueMtLr:

			{

			// Has the assitance data arrived?