// 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:
// Source file for the 'stub' network protocol module used in
// the Network Gateway unit tests.
// 
//

/**
 @file
 @internalTechnology
 @released
*/

#include <e32base.h>
#include <e32debug.h>
#include <ecom/implementationproxy.h>
#include <lbs.h>
#include "lbsdevloggermacros.h"
#include "lbsnetgatewayprotocoltest.h"


_LIT(KLbsTestNetworkProtocol,"LbsTestNetworkProtocol");


	
//
// ECom instantiation functions
//

const TImplementationProxy KImplementationTable[] = 
	{
	IMPLEMENTATION_PROXY_ENTRY(0x10282250, CTestLbsNetworkProtocol::New0L),
	IMPLEMENTATION_PROXY_ENTRY(0x10285AB9, CTestLbsNetworkProtocol::New1L),
	// Entry points for multiple PM test
	IMPLEMENTATION_PROXY_ENTRY(0x102871C8, CTestLbsNetworkProtocol::New2L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871C9, CTestLbsNetworkProtocol::New3L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871CA, CTestLbsNetworkProtocol::New4L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871CB, CTestLbsNetworkProtocol::New5L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871CC, CTestLbsNetworkProtocol::New6L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871CD, CTestLbsNetworkProtocol::New7L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871CE, CTestLbsNetworkProtocol::New8L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871CF, CTestLbsNetworkProtocol::New9L),

	// Another 10 entry points for the roaming PMs 
	IMPLEMENTATION_PROXY_ENTRY(0x102871D0, CTestLbsNetworkProtocol::New10L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D1, CTestLbsNetworkProtocol::New11L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D2, CTestLbsNetworkProtocol::New12L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D3, CTestLbsNetworkProtocol::New13L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D4, CTestLbsNetworkProtocol::New14L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D5, CTestLbsNetworkProtocol::New15L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D6, CTestLbsNetworkProtocol::New16L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D7, CTestLbsNetworkProtocol::New17L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D8, CTestLbsNetworkProtocol::New18L),
	IMPLEMENTATION_PROXY_ENTRY(0x102871D9, CTestLbsNetworkProtocol::New19L),
	};
	
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
	{
	aTableCount = (sizeof(KImplementationTable) / sizeof(TImplementationProxy));
	return KImplementationTable;
	}

//
// CTestLbsNetworkProtocol Implementation
//

CTestLbsNetworkProtocol::CTestLbsNetworkProtocol(TUint aModuleIndex, 
		TLbsNetProtocolModuleParams& aParams) : iObserver(aParams.Observer()),
		iTestChannel(aModuleIndex),
		iModuleIndex(aModuleIndex)
	{
	LBSLOG(ELogP1, "CTestLbsNetworkProtocol::CTestLbsNetworkProtocol:");
	}

CTestLbsNetworkProtocol::~CTestLbsNetworkProtocol()
	{
	LBSLOG(ELogP1, "CTestLbsNetworkProtocol::~CTestLbsNetworkProtocol:");
	iTestChannel.Close();
	RNetGatewayProtocolTestChannel::Shutdown(iModuleIndex);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New0L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New1L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex2, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New2L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex3, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New3L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex4, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New4L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex5, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New5L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex6, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New6L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex7, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New7L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex8, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New8L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex9, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New9L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex10, aData);
	}

CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New10L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex11, aData);
	}

// 10 entry points for roaming modules
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New11L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex12, aData);
	}
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New12L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex13, aData);
	}
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New13L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex14, aData);
	}
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New14L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex15, aData);
	}
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New15L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex16, aData);
	}
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New16L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex17, aData);
	}
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New17L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex18, aData);
	}
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New18L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex19, aData);
	}
CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New19L(TAny* aData)
	{
	return NewL(KTe_LbsNetGatewayTestProtocolIndex20, aData);
	}



CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::NewL(TUint aModuleIndex, TAny* aData)
	{
	LBSLOG(ELogP1, "CTestLbsNetworkProtocol::NewL:");
	TLbsNetProtocolModuleParams* params = reinterpret_cast<TLbsNetProtocolModuleParams*>(aData);
	CTestLbsNetworkProtocol* self = new (ELeave) CTestLbsNetworkProtocol(aModuleIndex, *params);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

void CTestLbsNetworkProtocol::ConstructL()
	{
	LBSLOG(ELogP1, "CTestLbsNetworkProtocol::ConstructL:");
	RNetGatewayProtocolTestChannel::InitialiseL(iModuleIndex);
	iTestChannel.OpenL(KTestAppChannelKey, KNetProtocolChannelKey, *this);	
	}

void CTestLbsNetworkProtocol::RespondPrivacyRequest(const TLbsNetSessionId& aSessionId,
							   						const TLbsPrivacyResponse& aResponse,
							   						TInt /* aReason */)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RespondPrivacyRequest:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());	
	LBSLOG2(ELogP2, "Response : %d", aResponse);
	
	TNetGatewayMsg msg;
	SNetMsgRespondPrivacyRequest* response;
	response = reinterpret_cast<SNetMsgRespondPrivacyRequest*>(msg.Data());	
	msg.iType = ENetMsgRespondPrivacyRequest;
	response->iSessionId = aSessionId;
	response->iResponse = aResponse;
	
	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}
	
void CTestLbsNetworkProtocol::RespondLocationRequest(const TLbsNetSessionId& aSessionId,
													 TInt  aReason,
													 const TPositionInfoBase& aPosInfo)
	{
	const TPositionInfo& posInfo = static_cast<const TPositionInfo&>(aPosInfo);
	TPosition position;
	posInfo.GetPosition(position);
	
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RespondLocationRequest:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());
	LBSLOG2(ELogP2, "Reason : %d", aReason);
	LBSLOG3(ELogP2, "Position : %LF lat, %LF long", position.Latitude(), 
													position.Longitude());
	
	SNetMsgRespondLocationRequest* response;
	TNetGatewayMsg msg;
	response = reinterpret_cast<SNetMsgRespondLocationRequest*>(msg.Data());
	new (response) SNetMsgRespondLocationRequest;
	msg.iType = ENetMsgRespondLocationRequest;
	response->iSessionId = aSessionId;
	response->iReason = aReason;
	// This assumes that aPosInfo is really a reference to 
	// a TPositionSatelliteInfo. If this isn't true then
	// the last part will be junk.
	Mem::Copy(&response->iPositionInfo, &aPosInfo, response->iPositionInfo.PositionClassSize());
	
	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	
	}

void CTestLbsNetworkProtocol::RequestAssistanceData(TLbsAssistanceDataGroup aDataRequestMask, const TLbsNetSessionIdArray& /*aSessionIdArray*/)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RequestAssistanceData:");
	LBSLOG2(ELogP2, "Data Mask : 0x%x", aDataRequestMask);
	
	TNetGatewayMsg msg;
	SNetMsgRequestAssistanceData* request;
	request = reinterpret_cast<SNetMsgRequestAssistanceData*>(msg.Data());
	msg.iType = ENetMsgRequestAssistanceData;
	request->iDataRequestMask = aDataRequestMask;
	
	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}

void CTestLbsNetworkProtocol::RequestSelfLocation(const TLbsNetSessionId& aSessionId,
													 const TLbsNetPosRequestOptionsBase& aOptions)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RequestNetworkBasedLocation:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());
	
	TNetGatewayMsg msg;
	SNetMsgRequestSelfLocation* request;
	request = reinterpret_cast<SNetMsgRequestSelfLocation*>(msg.Data());
	msg.iType = ENetMsgRequestSelfLocation;
	const TLbsNetPosRequestOptionsAssistance assistOptions = reinterpret_cast<const TLbsNetPosRequestOptionsAssistance&>(aOptions);
	request->iSessionId = aSessionId;
	request->iNewClient = assistOptions.NewClientConnected();
	request->iDataRequestMask = assistOptions.DataRequestMask();
	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}
	
void CTestLbsNetworkProtocol::CancelSelfLocation(const TLbsNetSessionId& aSessionId,
													 TInt aReason)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::CancelSelfLocation:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());
	LBSLOG2(ELogP2, "Reason : %d", aReason);
	
	TNetGatewayMsg msg;
	SNetMsgCancelSelfLocation* cancel;
	cancel = reinterpret_cast<SNetMsgCancelSelfLocation*>(msg.Data());
	msg.iType = ENetMsgCancelSelfLocation;
	cancel->iSessionId = aSessionId;
	cancel->iReason = aReason;

	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}

void CTestLbsNetworkProtocol::RequestNetworkLocation(const TLbsNetSessionId& aSessionId,
													 const TLbsNetPosRequestOptionsBase& aOptions)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RequestNetworkLocation:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());
	
	TNetGatewayMsg msg;
	SNetMsgRequestNetworkLocation* request;
	request = reinterpret_cast<SNetMsgRequestNetworkLocation*>(msg.Data());
	msg.iType = ENetMsgRequestNetworkLocation;
	const TLbsNetPosRequestOptions netOptions = reinterpret_cast<const TLbsNetPosRequestOptions&>(aOptions);
	netOptions.GetRequestQuality(request->iQuality);
	request->iSessionId = aSessionId;

	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}
	
void CTestLbsNetworkProtocol::CancelNetworkLocation(const TLbsNetSessionId& aSessionId,
													 TInt aReason)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::CancelNetworkLocation:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());
	LBSLOG2(ELogP2, "Reason : %d", aReason);
	
	TNetGatewayMsg msg;
	SNetMsgCancelNetworkLocation* cancel;
	cancel = reinterpret_cast<SNetMsgCancelNetworkLocation*>(msg.Data());
	msg.iType = ENetMsgCancelNetworkLocation;
	cancel->iSessionId = aSessionId;
	cancel->iReason = aReason;

	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}

void CTestLbsNetworkProtocol::RequestTransmitLocation(const TLbsNetSessionId& aSessionId,
													  const TDesC& aDestination,
													  TInt aPriority,
													  const TLbsNetPosRequestOptionsBase& aOptions)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RequestTransmitLocation:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());
	LBSLOG2(ELogP2, "Destination : %S", &aDestination);
	LBSLOG2(ELogP2, "Priority : %d", aPriority);
					
	TNetGatewayMsg msg;
	SNetMsgRequestTransmitLocation* request;
	request = reinterpret_cast<SNetMsgRequestTransmitLocation*>(msg.Data());
	new (request) SNetMsgRequestTransmitLocation; // in-place construction is needed to construct the descriptors (iDestination)
	msg.iType = ENetMsgRequestTransmitLocation;
	request->iSessionId = aSessionId;
	request->iPriority = aPriority;
	request->iDestination = aDestination;
	request->iOptions = reinterpret_cast<const TLbsNetPosRequestOptionsTechnology&>(aOptions);

	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}
	
void CTestLbsNetworkProtocol::CancelTransmitLocation(const TLbsNetSessionId& aSessionId,
													 TInt  aReason)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::CancelTransmitLocation:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());
	LBSLOG2(ELogP2, "Reason : %d", aReason);
	
	TNetGatewayMsg msg;
	SNetMsgCancelTransmitLocation* cancel;
	cancel = reinterpret_cast<SNetMsgCancelTransmitLocation*>(msg.Data());
	msg.iType = ENetMsgCancelTransmitLocation;
	cancel->iSessionId = aSessionId;
	cancel->iReason = aReason;

	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}

void CTestLbsNetworkProtocol::CancelExternalLocation(
									const TLbsNetSessionId& aSessionId,
									TInt aReason)
	{
	LBSLOG(ELogP2, "CTestLbsNetworkProtocol::CancelExternalLocation:");
	LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, 
											  aSessionId.SessionNum());
	LBSLOG2(ELogP2, "Reason : %d", aReason);
	
	TNetGatewayMsg msg;
	SNetMsgCancelExternalLocation* cancel;
	cancel = reinterpret_cast<SNetMsgCancelExternalLocation*>(msg.Data());
	msg.iType = ENetMsgCancelExternalLocation;
	cancel->iSessionId = aSessionId;
	cancel->iReason = aReason;

	TInt err = KErrNone;
	TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
	if(err)
		User::Panic(KLbsTestNetworkProtocol, err);
	}

	
void CTestLbsNetworkProtocol::AdviceSystemStatus(TLbsSystemStatus /*aStatus*/)
	{
#pragma message("NOTE: CTestLbsNetworkProtocol::AdviceSystemStatus method not yet implemented. TBD")
	}

void CTestLbsNetworkProtocol::ProcessNetProtocolMessage(const TNetGatewayMsg& aMessage)
	{
	LBSLOG(ELogP1, "CTestLbsNetworkProtocol::ProcessNetProtocolMessage:");
	
	switch (aMessage.iType)
		{
		case ENetMsgProcessPrivacyRequest:
			{
			const SNetMsgProcessPrivacyRequest* request;
			request = reinterpret_cast<const SNetMsgProcessPrivacyRequest*>(aMessage.Data());
			iObserver.ProcessPrivacyRequest(request->iSessionId,
											request->iEmergency,
											request->iPrivacy,
											request->iRequestInfo);
			break;
			}
		case ENetMsgProcessLocationRequest:
			{
			const SNetMsgProcessLocationRequest* request;
			request = reinterpret_cast<const SNetMsgProcessLocationRequest*>(aMessage.Data());
			iObserver.ProcessLocationRequest(request->iSessionId,
											  request->iEmergency,
											  request->iService,
											  request->iQuality,
											  request->iMethod);
			break;
			}
		case ENetMsgProcessSessionComplete:
			{
			const SNetMsgProcessSessionComplete* complete;
			complete = reinterpret_cast<const SNetMsgProcessSessionComplete*>(aMessage.Data());
			iObserver.ProcessSessionComplete(complete->iSessionId,
											  complete->iReason);
			break;
			}
		case ENetMsgProcessAssistanceData:
			{
			const SNetMsgProcessAssistanceData* data;
			data = reinterpret_cast<const SNetMsgProcessAssistanceData*>(aMessage.Data());
			iObserver.ProcessAssistanceData(data->iDataMask,
											data->iData, 
											data->iReason);
			break;
			}
		case ENetMsgProcessLocationUpdate:
			{
			const SNetMsgProcessLocationUpdate* location;
			location = reinterpret_cast<const SNetMsgProcessLocationUpdate*>(aMessage.Data());
			iObserver.ProcessLocationUpdate(location->iSessionId, location->iReferenceLocation);
			break;
			}
		case ENetMsgGetCurrentCapabilitiesRequest:
			{
			TNetGatewayMsg msg;
			msg.iType = ENetMsgGetCurrentCapabilitiesResponse;
			SNetMsgGetCurrentCapabilitiesResponse* response;
			response = reinterpret_cast<SNetMsgGetCurrentCapabilitiesResponse*>(msg.Data());
			iObserver.GetCurrentCapabilities(response->iCapabilities);

			TInt err = KErrNone;
			TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);)
			if(err)
				User::Panic(KLbsTestNetworkProtocol, err);
			break;
			}
		case ENetMsgProcessStatusUpdate:
			{
			const SNetMsgProcessStatusUpdate* status;
			status = reinterpret_cast<const SNetMsgProcessStatusUpdate*>(aMessage.Data());
			iObserver.ProcessStatusUpdate(status->iActiveServiceMask);
			break;
			}
		case ENetMsgRespondPrivacyRequest:
		case ENetMsgRespondLocationRequest:
		case ENetMsgRequestTransmitLocation:
		case ENetMsgCancelTransmitLocation:
		case ENetMsgCancelExternalLocation:
		case ENetMsgRequestAssistanceData:
		case ENetMsgRequestSelfLocation:
		case ENetMsgCancelSelfLocation:
		case ENetMsgRequestNetworkLocation:
		case ENetMsgCancelNetworkLocation:
		case ENetMsgGetCurrentCapabilitiesResponse:
			{
			// The message go from the the plugin to the test code,
			// so they should never be received here.
			break;
			}
		case ENetMsgShutdownNetGateway:
			{
			CActiveScheduler::Stop();
			break;
			}
		default:
			{
			LBSLOG_ERR2(ELogP3, "Unhandled message type ; %d\n", aMessage.iType);
			break;
			}
		}
	}