// Copyright (c) 2005-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:

// Client API to the LBS Network Simulator for 

// the (test) LBS protocol module.

// 

//

/**

 @file

 @internalTechnology

 @released

*/

#include <e32base.h>

#include <e32debug.h>

#include <ecom/ecom.h>

#ifdef SYMBIAN_FEATURE_MANAGER

	#include <featdiscovery.h>

	#include <featureuids.h>

#endif

#include <lbs/lbslocerrors.h>

#include <lbs/lbsadmin.h>

#include <lbs/lbslocclasstypes.h>

#include <lbs/lbsassistancedatabase.h>

#include <lbs/lbsassistancedatabuilderset.h>

#include <lbs/lbsnetcommon.h>

#include "lbscommoninternaldatatypes.h"

#include "LbsExtendModuleInfo.h"

#include "LbsInternalInterface.h"

#include "lbsdevloggermacros.h"

#include "netgateway.h"

#include "netregstatusmonitor.h"

#include <lbs/lbsgpsmeasurement.h>

#include "netgatewayasynccallback.h"

#include "netobserver.h"

#include "lbsnrhngmsgs.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "lbsnetextintversions.h"

#endif

const TInt KLbsLogQueueSize = 10;

// Privacy protocol module UID. This module is only currently used

// in standalone privacy mode, but this may change if this module

// is extended to support more than just privacy requests 

const TUid KPrivacyProtocolModuleUid = { 0x1028373C };

// Pre-defined technology type for autonomous.

const TPositionModuleInfo::TTechnologyType KAutonomous = (TPositionModuleInfo::ETechnologyTerminal);

// Pre-defined technology type for terminal-based (TB).

const TPositionModuleInfo::TTechnologyType KTerminalBased = (TPositionModuleInfo::ETechnologyTerminal

															 | TPositionModuleInfo::ETechnologyAssisted);

// Pre-defined technology type for terminal-assisted (TA).

const TPositionModuleInfo::TTechnologyType KTerminalAssisted = (TPositionModuleInfo::ETechnologyNetwork

																| TPositionModuleInfo::ETechnologyAssisted);

// Convert TLbsNetSessionId to TLbsNetSessionIdInt

#define TLBSNETSESSIONIDINT(sessionId) \

	TLbsNetSessionIdInt(sessionId.SessionOwner(), sessionId.SessionNum())

// Convert TLbsNetSessionIdInt to TLbsNetSessionId

#define TLBSNETSESSIONID(sessionId) \

	TLbsNetSessionId(sessionId.SessionOwner(), sessionId.SessionNum())

//

// CNetworkGateway

//

/**

*/

CNetworkGateway* CNetworkGateway::NewL()

	{

	CNetworkGateway* self = new (ELeave) CNetworkGateway;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;	

	}

/**

*/

CNetworkGateway::CNetworkGateway()

    {

    for (TInt index = 0; index < EInvalidSession; index++)

       {

       iModuleForSession[index] = NULL;

       }

	}

/**

*/	

CNetworkGateway::~CNetworkGateway()

	{

	LBSLOG(ELogP9, "->S CLbsNetworkProtocolBase::~ClbsNetworkProtocolBase() ProtocolModule\n");

	delete iExternalLogEvent;

	iLogger.Close();

	DeleteLoadedModules();

	delete iNetworkRequestChannel;

	delete iPSYChannel;

	delete iNetworkRegistrationStatusMonitor;

	delete iAgpsChannel;

	delete iNetworkLocationChannel;

	delete iAdmin;

	delete iCloseDownRequestDetector;

	delete iRejectPrivacyRequest;

	REComSession::FinalClose();

	#if defined(_DEBUG)

		if(iOomListener)

			{

			iOomListener->Cancel();

			delete iOomListener;

			}

	#endif 

	// Close the Subsession with the Location Monitor

	if ( iLocMonSubSession.SubSessionHandle() )

        {

        iLocMonSubSession.Close();

        }

	// Close the session with the Location Monitor

	if ( iLocMonSession.Handle() )

        {

        iLocMonSession.Close();

        }

	}

/**

*/	

void CNetworkGateway::ConstructL()

	{

	RProcess process;

	iCloseDownRequestDetector = CLbsCloseDownRequestDetector::NewL(this, process.SecureId());

	iAdmin = CLbsAdmin::NewL();

#ifdef SYMBIAN_FEATURE_MANAGER

	TBool locationManagementSupported = CFeatureDiscovery::IsFeatureSupportedL(NFeature::KLocationManagement);

#else

	TBool locationManagementSupported(ETrue);

	if(locationManagementSupported)

		{

		iNetworkLocationChannel = CNetworkLocationChannel::NewL(*this);

		iAgpsChannel = CAgpsChannel::NewL(*this);

		iNetworkRegistrationStatusMonitor = CNetworkRegistrationStatusMonitor::NewL(*this);

		}

	iNetworkRequestChannel = CNetworkRequestChannel::NewL(*this);

	iPSYChannel = CPsyRequestChannel::NewL(*this, RLbsNetChannel::EChannelNG2SUPLPSY);

	User::LeaveIfError(iAdmin->Get(KLbsProtocolModuleLoading, iLoadInfo));

	TLbsAdminProtocolModulesInfo homeModules;

	User::LeaveIfError(iAdmin->Get(KLbsSettingHomeProtocolModule, homeModules));

	TLbsAdminProtocolModulesInfo roamingModules;

	User::LeaveIfError(iAdmin->Get(KLbsSettingRoamingProtocolModule, roamingModules));

	homeModules.GetModuleIds(iHomePmUidArray, iHomePmCount);

	roamingModules.GetModuleIds(iRoamingPmUidArray,iRoamingPmCount);

	// Use the default protocol modules

	iHomePmUid		= iHomePmUidArray[0];

	iRoamingPmUid	= iRoamingPmUidArray[0];

	// Populate the list of all protocol modules with the home modules

	for(TInt homeIndex = 0; homeIndex < iHomePmCount; homeIndex++)

		{

		CProtocolModuleInfo* info = CProtocolModuleInfo::NewL(iHomePmUidArray[homeIndex], NULL, NULL, ETrue, EFalse);

		iModules[homeIndex] = info;

		}

	iPmCount = iHomePmCount;

	// Populate the list of all protocol modules with the roaming modules

	for(TInt roamingIndex = 0; roamingIndex < iRoamingPmCount; roamingIndex++)

		{

		TLbsProtocolModuleId pmId = iRoamingPmUidArray[roamingIndex];

		TBool alreadyPresent = EFalse;

		for(TInt index = 0; index < iHomePmCount; index++)

			{

			if(pmId == iModules[index]->ModuleUid())

				{

				alreadyPresent = ETrue;

				iModules[index]->SetRoaming(); // If already present then set it as roaming as well

				}

			}

		// If not present create it

		if(!alreadyPresent)

			{

			CProtocolModuleInfo* info = CProtocolModuleInfo::NewL(pmId, NULL, NULL, EFalse, ETrue);

			iModules[iPmCount] = info;

			iPmCount++;

			}

		}

	if (iHomePmUid == KPrivacyProtocolModuleUid)

		{

		TRAPD(err, LoadProtocolModuleL(iHomePmUid));

		iRegistrationStatus = RLbsNetworkRegistrationStatus::ERegisteredHomeNetwork;

		if (err != KErrNone)

			{

			LBSLOG_ERR3(ELogP3, "Error creating privacy protocol module UID 0x%x: %d",iHomePmUid , err);

			}

		}

	else if(iLoadInfo.LoadingStrategy()==TLbsAdminProtocolModuleLoadingInfo::EProtocolModuleLoadingAll)

		{

		for(TUint index = 0; index < iPmCount; index++)

			{

			TRAPD(err, LoadProtocolModuleL(iModules[index]->ModuleUid()));

			if (err != KErrNone)

				{

				LBSLOG_ERR3(ELogP3, "Error creating protocol module, err:%d uid:0x%h", err, (iModules[index]->ModuleUid()).iUid);

				}

			}

		}

	iRejectPrivacyRequest = CRejectPrivacyRequestCallback::NewL();

	iLogger.Open(KLbsLogQueueSize);

	#if defined(_DEBUG)

		// For OOM testing. The listener will force an error on the next heap 

		// allocation when it is kicked by test code.

		iOomListener = CLbsOomListener::NewL();

		iOomListener->StartGettingRequests();

	#endif  

	// Establish a session with the Location Monitor 

	if(KErrNone == iLocMonSession.Connect())

	    {

        // Open subsession  

        iLocMonSubSession.OpenL(iLocMonSession);

	    }

	}

/** Set flag indicating from which protocol module the latest network message originated.

*/

void CNetworkGateway::SetReceivingProtocolModule(TLbsProtocolModuleId aId)

	{

	iReceivingModuleId = aId;

	}

/** Select and load a Network Protocol Module.

Depending on admin options, two protocol modules are loaded at gateway initialisation

or a single module is loaded when the phone registers.

Loading is a 'one-off' process, nothing further is loaded (and nothing is unloaded) till phone reboots

*/

void CNetworkGateway::LoadProtocolModuleL(TLbsProtocolModuleId aModuleId)

	{

	if(aModuleId != KLbsProtocolNullModuleId)

	    {

        CProtocolModuleInfo* moduleInfo = ModuleInfo(aModuleId);

        CLbsNetworkProtocolBase* module = NULL;

        if(moduleInfo)

            {

            CNetObserver* obs = new (ELeave) CNetObserver(this, aModuleId);

            moduleInfo->SetObserver(obs);

            TLbsNetProtocolModuleParams params(*obs);

            LBSLOG(ELogP9, "->S CLbsNetworkProtocolBase::NewL() ProtocolModule\n");

            LBSLOG2(ELogP9, "  > TLbsProtocolModuleId moduleId  = 0x%08X\n", aModuleId);

            module = CLbsNetworkProtocolBase::NewL(aModuleId, params);

            moduleInfo->SetProtocolModule(module);

            }

	    }

	}

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

// Messages from a Protocol Module (MLbsNetworkProtocolObserver)

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

void CNetworkGateway::GetCurrentCapabilities(TLbsNetPosCapabilities& aCapabilities) const

	{

	LBSLOG(ELogP9, "<-A MLbsNetworkProtocolObserver::GetCurrentCapabilities() ProtocolModule\n");

	LBSLOG(ELogP2, "CNetworkGateway::GetCurrentCapabilities:");

	LBS_RDEBUG("ProtMod", "LBS", "GetCurrentCapabilities");

	// This call is not necessarily associated with a session, don't try to filter on current protocol module */

	TPositionModuleInfoExtended::TDeviceGpsModeCapabilities deviceGpsModeCaps(TPositionModuleInfo::ETechnologyUnknown);

	// Get the capabilities information to fill in the position method(s) for aCapabilities.

	TInt err = LbsModuleInfo::GetDeviceCapabilities(KLbsGpsLocManagerUid, deviceGpsModeCaps);

#ifdef ENABLE_LBS_DEV_LOGGER

	if (err != KErrNone)

		{

		LBSLOG_WARN2(ELogP3, "Error reading module info (%d), defaulting to 'unknown' pos method", err);

		}

#endif // ENABLE_LBS_DEV_LOGGER

	// Convert the module capabilities into a TLbsNetPosCapabilities..

	CLbsAdmin::TGpsMode adminGpsMode = GetAdminGpsMode();

	switch (deviceGpsModeCaps)

		{

		case TPositionModuleInfoExtended::EDeviceGpsModeTerminalBased:

			{

			TLbsNetPosMethod methods[2];

			methods[0].SetPosMethod(KLbsPositioningMeansGps, KTerminalBased);

			methods[1].SetPosMethod(KLbsPositioningMeansGps, KAutonomous);

			aCapabilities.SetPosMethods(methods, 2);

#ifdef ENABLE_LBS_DEV_LOGGER

			// Report a warning if the admin setting contradicts

			// the module capabilities.

			if (adminGpsMode != CLbsAdmin::EGpsPreferTerminalBased

				&& adminGpsMode != CLbsAdmin::EGpsAlwaysTerminalBased

				&& adminGpsMode != CLbsAdmin::EGpsAutonomous)

				{

				LBSLOG_WARN3(ELogP3, 

							 "KLbsSettingXXXGpsMode (%d) contradicts GPS module capabilties (0x%x)!", 

							 adminGpsMode,

							 deviceGpsModeCaps);

				}

#endif // ENABLE_LBS_DEV_LOGGER

			break;

			}

		case TPositionModuleInfoExtended::EDeviceGpsModeTerminalAssisted:

			{

			TLbsNetPosMethod method;

			method.SetPosMethod(KLbsPositioningMeansGps, KTerminalAssisted);

			aCapabilities.SetPosMethods(&method, 1);

#ifdef ENABLE_LBS_DEV_LOGGER

			// Report a warning if the admin setting contradicts

			// the module capabilities.

			if (adminGpsMode != CLbsAdmin::EGpsPreferTerminalAssisted

				&& adminGpsMode != CLbsAdmin::EGpsAlwaysTerminalAssisted)

				{

				LBSLOG_WARN3(ELogP3, 

							 "KLbsSettingXXXGpsMode (%d) contradicts GPS module capabilties (0x%x)!", 

							 adminGpsMode,

							 deviceGpsModeCaps);

				}

#endif // ENABLE_LBS_DEV_LOGGER

			break;

			}

		case TPositionModuleInfoExtended::EDeviceGpsModeSimultaneousTATB:

		case (TPositionModuleInfoExtended::EDeviceGpsModeTerminalBased

			  | TPositionModuleInfoExtended::EDeviceGpsModeTerminalAssisted):

			{

			// If the module supports both TA and TB, then check the admin

			// settings to find the 'preferred' one to put first in the 

			// list of supported modes.			

			TLbsNetPosMethod methods[3];

			switch (adminGpsMode)

				{

				case CLbsAdmin::EGpsAlwaysTerminalAssisted:

				case CLbsAdmin::EGpsPreferTerminalAssisted:

					{

					methods[0].SetPosMethod(KLbsPositioningMeansGps, KTerminalAssisted);

					methods[1].SetPosMethod(KLbsPositioningMeansGps, KTerminalBased);

					break;

					}

				case CLbsAdmin::EGpsAutonomous:

				case CLbsAdmin::EGpsAlwaysTerminalBased:

				case CLbsAdmin::EGpsPreferTerminalBased:

				default:

					{

					methods[0].SetPosMethod(KLbsPositioningMeansGps, KTerminalBased);

					methods[1].SetPosMethod(KLbsPositioningMeansGps, KTerminalAssisted);

					break;

					}

				}

			methods[2].SetPosMethod(KLbsPositioningMeansGps, KAutonomous);

			aCapabilities.SetPosMethods(methods, 3);

			break;

			}

		case TPositionModuleInfoExtended::EDeviceGpsModeAutonomous:

			{

			TLbsNetPosMethod method;

			method.SetPosMethod(KLbsPositioningMeansGps, KAutonomous);

			aCapabilities.SetPosMethods(&method, 1);

#ifdef ENABLE_LBS_DEV_LOGGER

			// Report a warning if the admin setting contradicts

			// the module capabilities.

			if (adminGpsMode != CLbsAdmin::EGpsAutonomous)

				{

				LBSLOG_WARN3(ELogP3, 

							 "KLbsSettingXXXGpsMode (%d) contradicts GPS module capabilties (0x%x)!", 

							 adminGpsMode,

							 deviceGpsModeCaps);

				}

#endif // ENABLE_LBS_DEV_LOGGER

			break;

			}

		case TPositionModuleInfoExtended::EDeviceGpsModeNone:

		default:

			{

			// If the capabilities are not known or unrecognised, set unknown pos method.

			TLbsNetPosMethod method;

			method.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyUnknown);

			aCapabilities.SetPosMethods(&method, 1);

			LBSLOG_WARN3(ELogP3, 

						 "Unrecognised GPS module capabilities (%d), defaulting to TPositionModuleInfo::ETechnologyUnknown", 

						 adminGpsMode, 

						 deviceGpsModeCaps);

			break;

			}

		}

	}

void CNetworkGateway::ProcessStatusUpdate(TLbsNetProtocolServiceMask /*aActiveServiceMask*/)

	{

	LBSLOG(ELogP9, "<-A MLbsNetworkProtocolObserver::ProcessStatusUpdate() ProtocolModule\n");

	LBSLOG(ELogP2, "CNetworkGateway::ProcessStatusUpdate:");

	LBS_RDEBUG("ProtMod", "LBS", "ProcessStatusUpdate");

	//LBSLOG2(ELogP2, "Active Service Mask : 0x%x", aActiveServiceMask);

	// TODO: It is TBD exactly what/where this update should go.

	// For now, just consume it.

	}

void CNetworkGateway::ProcessPrivacyRequest(const TLbsNetSessionId& aSessionId,

										    TBool aEmergency, 

										    const TLbsNetPosRequestPrivacy& aPrivacy,

										    const TLbsExternalRequestInfo& aRequestInfo)

	{

	LBS_RDEBUG("ProtMod", "LBS", "ProcessPrivacyRequest");

	__ASSERT_ALWAYS((aRequestInfo.ClassType() == EExternalRequestInfoClass)

					|| (aRequestInfo.ClassType() == (EExternalRequestInfoClass 

													| EExternalRequestInfoClass2)),

					User::Panic(_L("LbsNetGateway"), 2));

	LBSLOG(ELogP9, "<-A MLbsNetworkProtocolObserver::ProcessPrivacyRequest() ProtocolModule\n");

	LBSLOG(ELogP9, "  > TLbsNetSessionId aSessionId  = \n");

	LBSLOG_SESSIONID(aSessionId);

	LBSLOG2(ELogP9, "  > TBool aEmergency  = %d\n", aEmergency);

	LBSLOG(ELogP9, "  > TLbsNetPosRequestPrivacy aPrivacy  =\n");

	LBSLOG_POSREQUESTPRIVACY(aPrivacy);

	/** LBSLOGGER - Start Logging */

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

	TInt err = KErrNone;

	if(iExternalLogEvent == NULL)

		TRAP(err, iExternalLogEvent = CLbsExternalLocateLogEvent::NewL(aSessionId.SessionOwner(), NULL, NULL));

	if (err == KErrNone)

		{

		TLbsLoggingPrivacyRequestParams params;

		params.iSessionId = aSessionId;

		// Only TLbsExternalRequestInfo is logged, so if aRequestInfo

		// is a TLbsExternalRequestInfo2, the string(s) will be truncated.

		params.iRequestInfo = aRequestInfo;

		params.iRequestPrivacy =  aPrivacy;

		iExternalLogEvent->SetPrivacyRequestParams(params);

		}

	LBSLOG(ELogP9, "  < TLbsExternalRequestInfo aRequestInfo  =\n");

	//LBSLOG_TLBSEXTERNALREQ(aRequestInfo);

	// Convert aPrivacy to TLbsNetPosRequestPrivacyInt

	// because it is used to createTLbsNetMtLrRequestMsg.

	TLbsNetPosRequestPrivacyInt privacyInt;

	privacyInt.SetRequestAdvice((TLbsNetPosRequestPrivacyInt::TLbsRequestAdviceInt)

			aPrivacy.RequestAdvice());

	privacyInt.SetRequestAction((TLbsNetPosRequestPrivacyInt::TLbsRequestActionInt)

			aPrivacy.RequestAction());

	TLbsNetMtLrRequestMsg msg(

			TLBSNETSESSIONIDINT(aSessionId),

			aEmergency, privacyInt, aRequestInfo);

	if(ValidPm(aSessionId.SessionOwner()))

		{

		iNetworkRequestChannel->SendNetRequestMessage(msg);

		}

	else

		{

		//Not a valid PM, reject this message(rather than silently ignore??)

		iRejectPrivacyRequest->CallBack((ModuleInfo(aSessionId.SessionOwner()))->ProtocolModule(), aSessionId);	

		}

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

	/** LBSLOGGER - End Logging */

	}

void CNetworkGateway::ProcessLocationRequest(const TLbsNetSessionId& aSessionId,

											 TBool aEmergency,

											 TLbsNetProtocolService aService, 

											 const TLbsNetPosRequestQuality& aQuality,

											 const TLbsNetPosRequestMethod& aMethod)

	{

	LBS_RDEBUG("ProtMod", "LBS", "ProcessLocationRequest");

	LBSLOG(ELogP9, "<-A MLbsNetworkProtocolObserver::ProcessLocationRequest() ProtocolModule\n");

	LBSLOG(ELogP9, "  > TLbsNetSessionId aSessionId  = \n");

	LBSLOG_SESSIONID(aSessionId);

	LBSLOG2(ELogP9, "  > TBool aEmergency  = %d\n", aEmergency);

	LBSLOG2(ELogP9, "  > TLbsNetProtocolService aService  = 0x%02X\n", aService);

	LBSLOG(ELogP9, "  > TLbsNetPosRequestQuality aQuality  = \n");

	LBSLOG_POSREQUESTQUALITY(aQuality);	

	LBSLOG(ELogP9, "  > TLbsNetPosRequestMethod aMethod  =\n");

	LBSLOG_POSREQUESTMETHOD(aMethod);

	// If the received message is from a protocol module that is not registered reject it

	if(!ValidPm(iReceivingModuleId))

		{

		return;

		}

	// Convert aQuality to TLbsNetPosRequestQualityInt

	// because it is needed to create TLbsNetLocationRequestMsg.