// 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 "lbsnetsimtesthandler.h"

#include "lbsnetsimassistancedataprovider.h"

#include "lbsnetsimgatewayhandler.h"

#include <lbspositioninfo.h>

#include <lbs/lbslocdatasourcegpsbase.h>

#include <lbs/test/lbsnetsimstatus.h>

#include <s32mem.h>

#include <e32property.h>

/**

*/

CLbsNetSimTestHandler* CLbsNetSimTestHandler::NewL(CLbsNetSimAssistanceDataProvider& aAssistanceDataProvider)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

*/

void CLbsNetSimTestHandler::SetGatewayHandler(CLbsNetSimGatewayHandler* aGatewayHandler)

	{

	iGatewayHandler = aGatewayHandler;

	}

/**

*/

void CLbsNetSimTestHandler::ServiceL(const RMessage2& aMessage)

	{

	switch (aMessage.Function())

		{

		case ECallbacks:

			{

			HandleCallbacksL(aMessage);

			break;

			}

		case ETSetReferenceLocation:

			{

			HandleSetReferenceLocationL(aMessage);

			break;

			}

		case ETSetReferenceLocationData:

			{

			HandleSetReferenceLocationDataL(aMessage);

			break;

			}

		case ETSetResponseTime:

			{

			HandleSetResponseTime(aMessage);

			break;

			}

		case ETSetResponseError:

			{

			HandleSetResponseError(aMessage);

			break;

			}

		case ETSetDefaultAssitanceDataFilter:

			{

			HandleSetDefaultAssitanceDataFilter(aMessage);

			break;

			}

		case ETSetMoreDefaultAssitanceDataFilter:

			{

			HandleSetMoreDefaultAssitanceDataFilter(aMessage);

			break;

			}

		case ETClearAssitanceDataFilters:

			{

			HandleClearAssitanceDataFilters(aMessage);

			break;

			}

		case ETSetAssistanceDataProvider:

			{

			HandleSetAssistanceDataProvider(aMessage);

			break;

			}

		case ETSetEmergenyStatus:

			{

			HandleSetEmergenyStatus(aMessage);

			break;

			}

		case ETSetRoamingStatus:		

			{

			HandleSetRoamingStatus(aMessage);

			break;

			}

		case ETSetRequestQuality:		

			{

			HandleSetQuality(aMessage);

			break;

			}

		case ETSetStepMode:

			{

			HandleSetStepMode(aMessage);

			break;

			}

		case ETReleaseLcsLocationNotification:

			{

			HandleReleaseLcsLocationNotificationL(aMessage);

			break;

			}

		case ETReleaseLcsLocationNotificationCancel:

			{

			if (!iMessageReleaseLcsLocationNotification.IsNull())

				{

				iMessageReleaseLcsLocationNotification.Complete(KErrCancel);

				}

			break;

			}

		case ETStartNetworkLocationRequest:

			{

			HandleStartNetworkLocationRequestL(aMessage);

			break;

			}

		case ETStartNetworkLocationRequestCancel:

			{

			if (!iMessageStartNetworkLocationRequest.IsNull())

				{

				iMessageStartNetworkLocationRequest.Complete(KErrCancel);

				}

			break;

			}

		case ETSendResetAssistanceData:

			{

			HandleSendResetAssistanceData(aMessage);

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			}

		}

	}

/**

*/

void CLbsNetSimTestHandler::Connected()

	{

	iFireConnectedNotification = ETrue;

	// Attach to step mode property

	iStepModeProperty.Attach(TUid::Uid(KLbsNetSimClient), KLbsStepModeKey);

	}

/**

*/

void CLbsNetSimTestHandler::Disconnected()

	{

	// Clean up some values

	RProperty::Set(TUid::Uid(KLbsNetSimStatus), KLbsRoamingStatus, EFalse);

	RProperty::Set(TUid::Uid(KLbsNetSimStatus), KLbsEmergencyStatus, EFalse);

	// Detach from step mode property

	iStepModeProperty.Close();

	// Complete any outstanding RMessage2's

	if (!iMessageConnect.IsNull())

		{

		iMessageConnect.Complete(KErrDisconnected);

		}

	if (!iMessageDisconnect.IsNull())

		{

		iMessageDisconnect.Complete(KErrDisconnected);

		}

	if (!iMessageRegisterLcsMoLr.IsNull())

		{

		iMessageRegisterLcsMoLr.Complete(KErrDisconnected);

		}

	if (!iMessageMeasurementControlLocation.IsNull())

		{

		iMessageMeasurementControlLocation.Complete(KErrDisconnected);

		}

	if (!iMessageReleaseLcsMoLr.IsNull())

		{

		iMessageReleaseLcsMoLr.Complete(KErrDisconnected);

		}

	if (!iMessageReleaseLcsLocationNotification.IsNull())

		{

		iMessageReleaseLcsLocationNotification.Complete(KErrDisconnected);

		}

	if (!iMessageMeasurementReportLocation.IsNull())

		{

		iMessageMeasurementReportLocation.Complete(KErrDisconnected);

		}

	if (!iMessageMeasurementReportRequestMoreAssitanceData.IsNull())

		{

		iMessageMeasurementReportRequestMoreAssitanceData.Complete(KErrDisconnected);

		}

	if (!iMessageMeasurementReportControlFailure.IsNull())

		{

		iMessageMeasurementReportControlFailure.Complete(KErrDisconnected);

		}

	if (!iMessageFacilityLcsMoLrResult.IsNull())

		{

		iMessageFacilityLcsMoLrResult.Complete(KErrDisconnected);

		}

	if (!iMessageStartNetworkLocationRequest.IsNull())

		{

		iMessageStartNetworkLocationRequest.Complete(KErrDisconnected);

		}

	}

/**

*/

TInt CLbsNetSimTestHandler::GatewayConnected()

	{

	if (!iMessageConnect.IsNull())

		{

		iMessageConnect.Complete(KErrNone);

		iFireConnectedNotification = EFalse;

		}

	else

		{

		iFireConnectedNotification = ETrue;

		}

	iGatewayConnected = ETrue;

	return KErrNone;

	}

/**

*/

TInt CLbsNetSimTestHandler::GatewayDisconnected()

	{

	if (!iMessageDisconnect.IsNull())

		{

		iMessageDisconnect.Complete(KErrNone);

		}

	iGatewayConnected = EFalse;

	return KErrNone;

	}

/**

*/

TInt CLbsNetSimTestHandler::GatewayRegisterLcsMoLr(const TDesC& aData)

	{

	TInt ret = KErrNone;

	if (!iMessageRegisterLcsMoLr.IsNull())

		{

		iMessageRegisterLcsMoLr.Write(1, aData, 0);

		iMessageRegisterLcsMoLr.Complete(KErrNone);

		ret = StepModeWait();

		}

	return ret;

	}

TInt CLbsNetSimTestHandler::GatewayProcessAssistanceDataL(RLbsAssistanceDataBuilderSet& aAssistanceData, 

														  TPositionInfo& aPosition,  

														  TLbsNetPosRequestQuality& aQuality)

	{

	TInt ret = KErrNone;

	if (!iMessageMeasurementControlLocation.IsNull())

		{

		// Write position to message

		TPckg<TPositionInfo> positionPkg(aPosition);

		iMessageMeasurementControlLocation.WriteL(1, positionPkg, 0);

		// Write quality to message

		TPckg<TLbsNetPosRequestQuality> qualityPkg(aQuality);

		iMessageMeasurementControlLocation.WriteL(2, 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();

		iMessageMeasurementControlLocation.WriteL(3, des, 0);

		CleanupStack::PopAndDestroy(2, buffer);

		iMessageMeasurementControlLocation.Complete(KErrNone);

		ret = StepModeWait();

		} // if

	return ret;

	}

/**

*/	

TInt CLbsNetSimTestHandler::GatewayMeasurementReportLocationL(const TPositionInfo& aPosition)

	{

	TInt ret = KErrNone;

	if (!iMessageMeasurementReportLocation.IsNull())

		{

		// Write args

		TPckg<TPositionInfo> positionPkg(aPosition);

		iMessageMeasurementReportLocation.WriteL(1, positionPkg, 0);

		iMessageMeasurementReportLocation.Complete(KErrNone);

		ret = StepModeWait();

		} // if

	return ret;

	}

/**

*/

TInt CLbsNetSimTestHandler::GatewayFacilityLcsMoLrResultL(const TInt aReason, const TPositionInfo& aPosition)

	{

	TInt ret = KErrNone;

	if (!iMessageFacilityLcsMoLrResult.IsNull())

		{

		// Write args

		TPckg<TInt> reasonPkg(aReason);

		TPckg<TPositionInfo> positionPkg(aPosition);

		iMessageFacilityLcsMoLrResult.WriteL(1, reasonPkg, 0);

		iMessageFacilityLcsMoLrResult.WriteL(2, positionPkg, 0);

		iMessageFacilityLcsMoLrResult.Complete(KErrNone);

		ret = StepModeWait();

		}

	return ret;

	}

TInt CLbsNetSimTestHandler::GatewayReleaseLcsMoLrL(const TInt aReason)

	{

	TInt ret = KErrNone;

	if (!iMessageReleaseLcsMoLr.IsNull())

		{

		// Write args

		TPckg<TInt> reasonPkg(aReason);

		iMessageReleaseLcsMoLr.WriteL(1, reasonPkg, 0);

		iMessageReleaseLcsMoLr.Complete(KErrNone);

		ret = StepModeWait();

		}

	return ret;

	}

/**

*/

TInt CLbsNetSimTestHandler::GatewayMeasurementControlFailureL(const TInt aReason)

	{

	TInt ret = KErrNone;

	if (!iMessageMeasurementReportControlFailure.IsNull())

		{

		// Write args

		TPckg<TInt> reasonPkg(aReason);

		iMessageMeasurementReportControlFailure.WriteL(1, reasonPkg, 0);

		iMessageMeasurementReportControlFailure.Complete(KErrNone);

		ret = StepModeWait();

		}

	return ret;

	}

/**

*/

TInt CLbsNetSimTestHandler::GatewayRequestMoreAssistanceDataL(const TLbsAssistanceDataGroup& aFilter)

	{

	TInt ret = KErrNone;

	if (!iMessageMeasurementReportRequestMoreAssitanceData.IsNull())

		{

		// Write args

		TPckg<TLbsAssistanceDataGroup> filterPkg(aFilter);

		iMessageMeasurementReportRequestMoreAssitanceData.WriteL(1, filterPkg, 0);

		iMessageMeasurementReportRequestMoreAssitanceData.Complete(KErrNone);

		ret = StepModeWait();

		}

	return ret;

	}

/**

*/

TInt CLbsNetSimTestHandler::GatewayReleaseLcsLocationNotificationL(const CLbsNetworkProtocolBase::TLbsPrivacyResponse& aResponse)

	{

	TInt ret = KErrNone;

	if (!iMessageReleaseLcsLocationNotification.IsNull())

		{

		TPckg<CLbsNetworkProtocolBase::TLbsPrivacyResponse> responsePkg(aResponse);

		iMessageReleaseLcsLocationNotification.WriteL(2, responsePkg, 0);

		iMessageReleaseLcsLocationNotification.Complete(KErrNone);

		ret = StepModeWait();

		}

	return ret;	

	}

//

// Private

/**

*/

CLbsNetSimTestHandler::CLbsNetSimTestHandler(CLbsNetSimAssistanceDataProvider& aAssitanceDataProvider) :

	iAssistanceDataProvider(aAssitanceDataProvider), iGatewayConnected(EFalse), 

	iFireConnectedNotification(EFalse), iStepMode(EFalse)

	{

	}

/**

*/

void CLbsNetSimTestHandler::ConstructL()

	{

	// Create publish & subscribe flags

	TUid statusUid = TUid::Uid(KLbsNetSimStatus);

	TInt err = RProperty::Define(KLbsEmergencyStatus, RProperty::EInt, ECapability_None, ECapabilityWriteDeviceData, EFalse);

	if ((err != KErrNone) && (err != KErrAlreadyExists))

		{

		User::Leave(err);

		}

	User::LeaveIfError(RProperty::Set(statusUid, KLbsEmergencyStatus, EFalse));

	err = RProperty::Define(statusUid, KLbsRoamingStatus, RProperty::EInt, ECapability_None, ECapabilityWriteDeviceData);

	if ((err != KErrNone) && (err != KErrAlreadyExists))

		{

		User::Leave(err);

		}

	User::LeaveIfError(RProperty::Set(statusUid, KLbsRoamingStatus, EFalse));

	}

/**

*/

void CLbsNetSimTestHandler::HandleCallbacksL(const RMessage2& aMessage)

	{

	switch (aMessage.Int0())

		{

		case ENotificationConnect:

			{

			iMessageConnect = aMessage;

			if (iGatewayConnected && iFireConnectedNotification)

				{

				iMessageConnect.Complete(KErrNone);

				iFireConnectedNotification = EFalse;

				}

			break;

			}

		case ENotificationConnectCancel:

			{

			if (!iMessageConnect.IsNull())

				{

				iMessageConnect.Complete(KErrCancel);

				}

			aMessage.Complete(KErrNone);

			break;

			}

		case ENotificationDisconnect:

			{

			iMessageDisconnect = aMessage;

			break;

			}

		case ENotificationDisconnectCancel:

			{

			if (!iMessageDisconnect.IsNull())

				{

				iMessageDisconnect.Complete(KErrCancel);

				}

			aMessage.Complete(KErrNone);

			break;

			}

		case ENotificationRegisterLcsMoLr:

			{

			iMessageRegisterLcsMoLr = aMessage;

			break;

			}

		case ENotificationRegisterLcsMoLrCancel:

			{