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

// suplproxyprivacysession.cpp

// 

//

#include "lbsdevloggermacros.h"

#include "suplproxyprivacysession.h"

#include "suplproxyprivacyrequestinfo.h"

#include "suplproxyprotocol.h"

#include "EPos_PrivacyServerPanic.h"

#include <lbs/lbsprivacyrequestcommon.h>

/**

Constructor.

@param aProtocol Interface to send supl proxy requests to.

*/

CSuplProxyPrivacySession::CSuplProxyPrivacySession(MSuplProxyPrivacyProtocol& aProtocol, 

									 TLbsProxyApiType aApiType) :

	iPrivacyProtocol(aProtocol),

	iApiType(aApiType)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::CSuplProxyPrivacySession() Begin And End \n");

	}

/**

Destructor.

*/

CSuplProxyPrivacySession::~CSuplProxyPrivacySession()

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::~CSuplProxyPrivacySession() Begin and End\n");

	}

/**

Called when the session is created.

*/

void CSuplProxyPrivacySession::CreateL()

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::CreateL() Begin\n");

	Server().IncSessionCount(iApiType);

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::CreateL() End\n");

	}

/**

Called when a message is received for this session.

@param aMessage The message from the client.

*/

void CSuplProxyPrivacySession::ServiceL(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::ServiceL() Begin\n");

	switch (aMessage.Function())

		{

		case ELbsPrivacyServerNotifyLocation:

			NotifyLocationRequest(aMessage);

			break;

		case ELbsPrivacyServerVerifyLocation:

			VerifyLocationRequest(aMessage);

			break;

		case ELbsPrivacyServerNotifyVerificationTimeout:

			NotifyVerificationTimeout(aMessage);

			break;

		case ELbsPrivacyServerCancelVerifyLocationRequest:

			CancelVerifyLocationRequest(aMessage);

			break;

		case ELbsPrivacyServerNewPrivacyRequestLocal:

		case ELbsPrivacyServerNewPrivacyRequestNetwork:

			NewPrivacyRequest(aMessage);

			break;

		case ELbsPrivacyServerRepeatPrivacyRequestLocal:

		case ELbsPrivacyServerRepeatPrivacyRequestNetwork:

			RepeatPrivacyRequest(aMessage);

			break;

		case ELbsPrivacyServerCompleteRequest:

			CompleteRequest(aMessage);

			break;

		default:

			User::Leave(KErrNotSupported);

		}

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::ServiceL() End\n");

	}

/**

Called when the session disconnects.

@param aMessage The message from the client.

*/

void CSuplProxyPrivacySession::Disconnect(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::Disconnect() Begin\n");

	TInt reason(aMessage.Int1());

	iPrivacyProtocol.PrivacySessionDisconnected(this,reason);

	Server().DecSessionCount(iApiType);

	CSession2::Disconnect(aMessage);

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::Disconnect() End\n");

	}

/**

Get a reference to the server for this session.

@return A reference to the CSuplProxyServer.

*/

CSuplProxyServer& CSuplProxyPrivacySession::Server()

	{

	return *static_cast<CSuplProxyServer*>(const_cast<CServer2*>(CSession2::Server()));

	}

/**

Cancel a verification request.

@param aMessage The message from the client.

*/

void CSuplProxyPrivacySession::CancelVerifyLocationRequest(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::CancelVerifyLocationRequest() Begin\n");

	CCancelSuplProxyPrivacyRequestInfo* cancelInfo = NULL;

	TRAPD(err, cancelInfo = CCancelSuplProxyPrivacyRequestInfo::NewL());

	if (err != KErrNone)

		{

		// Error creating request info object, complete with the error and return

		aMessage.Complete(err);

		return;

		}

	cancelInfo->SetRequestId(aMessage.Int0());

	cancelInfo->SetCancelReason(aMessage.Int1());

	if (!IsRequestInfoValid(*cancelInfo))

		{

		aMessage.Panic(KPosPrivacyPanicCategory,

					   EPosPrivSrvPanicRequestOverflow);

		delete cancelInfo;

		return;

		}

	aMessage.Complete(KErrNone);

	iPrivacyProtocol.CancelVerifyLocationRequest(cancelInfo);

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::CancelVerifyLocationRequest() End\n");

	}

/**

Submit a notification request.

@param aMessage The message from the client.

*/

void CSuplProxyPrivacySession::NotifyLocationRequest(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::NotifyLocationRequest() Begin\n");

	TLbsNetSessionId sessionId;

	iPrivacyProtocol.GetNextSessionId(sessionId);

	TPckg<TInt> pkgReqId(sessionId.SessionNum());

	TInt error = aMessage.Write(1,pkgReqId);

	if(error != KErrNone)

		{

		aMessage.Complete(error);

		return;

		}

	// NOTE: requestInfo does not complete the message in this case

	CSuplProxyPrivacyRequestInfo* requestInfo = NULL;

	TRAPD(err, requestInfo = CSuplProxyPrivacyRequestInfo::NewL(aMessage));

	if (err != KErrNone)

		{

		// Error creating request info object, complete with the error and return

		aMessage.Complete(err);

		return;

		}

	TLbsExternalRequestInfo2 extRequestInfo;

    TPckg<TLbsExternalRequestInfo2> extRequestInfoPkg(extRequestInfo);

    aMessage.Read(0,extRequestInfoPkg);

    requestInfo->SetRequestInfo(extRequestInfo);

	requestInfo->SetRequestId(sessionId.SessionNum());

	TLbsNetPosRequestPrivacy netPosRequestPrivacy;

	TPckg<TLbsNetPosRequestPrivacy>	netPosRequestPrivacyPkg(netPosRequestPrivacy);

	aMessage.Read(2,netPosRequestPrivacyPkg);

	requestInfo->SetRequestPrivacy(netPosRequestPrivacy);

    requestInfo->SetIsResponseRequired(EFalse);

	if (!IsRequestInfoValid(*requestInfo))

		{

		aMessage.Panic(KPosPrivacyPanicCategory,

					   EPosPrivSrvPanicInvalidArguments);

		delete requestInfo;

		return;

		}

	iPrivacyProtocol.NotifyLocationRequest(requestInfo);

	aMessage.Complete(KErrNone);

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::NotifyLocationRequest() End\n");

	}

/**

Submit a notification timeout request.

@param aMessage The message from the client.

*/

void CSuplProxyPrivacySession::NotifyVerificationTimeout(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::NotifyVerificationTimeout() Begin\n");

	// NOTE: requestInfo does not complete the message in this case

	CSuplProxyPrivacyRequestInfo* requestInfo = NULL;

	TRAPD(err, requestInfo = CSuplProxyPrivacyRequestInfo::NewL(aMessage));

	if (err != KErrNone)

		{

		// Error creating request info object, complete with the error and return

		aMessage.Complete(err);

		return;

		}

    TLbsExternalRequestInfo2 extRequestInfo;

    TPckg<TLbsExternalRequestInfo2> extRequestInfoPkg(extRequestInfo);

    aMessage.Read(0,extRequestInfoPkg);

    requestInfo->SetRequestInfo(extRequestInfo);

	requestInfo->SetRequestId(aMessage.Int1());

	TLbsNetPosRequestPrivacy netPosRequestPrivacy;

	TPckg<TLbsNetPosRequestPrivacy>	netPosRequestPrivacyPkg(netPosRequestPrivacy);

	aMessage.Read(2,netPosRequestPrivacyPkg);

	requestInfo->SetRequestPrivacy(netPosRequestPrivacy);

	requestInfo->SetIsResponseRequired(EFalse);

	if (!IsRequestInfoValid(*requestInfo))

		{

		aMessage.Panic(KPosPrivacyPanicCategory,

					   EPosPrivSrvPanicInvalidArguments);

		delete requestInfo;

		return;

		}

	// temporary. Since NRH state machine can't deal with receiving a second privacy request while waiting for a location request, complete the first session so we start a new one.

	iPrivacyProtocol.EndPrivacySession(aMessage.Int1(), KErrNone);	 

	iPrivacyProtocol.NotifyVerificationTimeout(requestInfo);

	aMessage.Complete(KErrNone);

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::NotifyVerificationTimeout() End\n");

	}

/**

Submit a verify location request.

@param aMessage The message from the client.

*/

void CSuplProxyPrivacySession::VerifyLocationRequest(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::VerifyLocationRequest() Begin\n");

	TLbsNetSessionId sessionId;

	iPrivacyProtocol.GetNextSessionId(sessionId);

	TPckg<TInt> pkgReqId(sessionId.SessionNum());

	TInt error = aMessage.Write(0,pkgReqId);

	if(error != KErrNone)

		{

		aMessage.Complete(error);

		return;

		}

	RSemaphore semaphore;

	error = semaphore.Open(aMessage, 3, EOwnerThread);

	if(error != KErrNone)

		{

		aMessage.Complete(error);

		return;

		}

	semaphore.Signal();

	semaphore.Close();

	CSuplProxyPrivacyRequestInfo* requestInfo = NULL;

	TRAPD(err, requestInfo = CSuplProxyPrivacyRequestInfo::NewL(aMessage));

	if (err != KErrNone)

		{

		// Error creating request info object, complete with the error and return

		aMessage.Complete(err);

		return;

		}

	requestInfo->SetRequestId(sessionId.SessionNum());

    TLbsExternalRequestInfo2 extRequestInfo;

    TPckg<TLbsExternalRequestInfo2> extRequestInfoPkg(extRequestInfo);

    aMessage.Read(1,extRequestInfoPkg);

    requestInfo->SetRequestInfo(extRequestInfo);

	TLbsNetPosRequestPrivacy netPosRequestPrivacy;

	TPckg<TLbsNetPosRequestPrivacy>	netPosRequestPrivacyPkg(netPosRequestPrivacy);

	aMessage.Read(2,netPosRequestPrivacyPkg);

	requestInfo->SetRequestPrivacy(netPosRequestPrivacy);

	requestInfo->SetIsResponseRequired(ETrue);

	if (!IsRequestInfoValid(*requestInfo))

		{

		aMessage.Panic(KPosPrivacyPanicCategory,

					   EPosPrivSrvPanicInvalidArguments);

		delete requestInfo;

		return;

		}

	iPrivacyProtocol.VerifyLocationRequest(requestInfo);

	// The message should be completed later in this case

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::VerifyLocationRequest() End\n");

	}

void CSuplProxyPrivacySession::NewPrivacyRequest(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::NewPrivacyRequest() Begin\n");

	TLbsNetSessionId sessionId;

	iPrivacyProtocol.GetNextSessionId(sessionId);

	TPckg<TUint32> pkgReqId(sessionId.SessionNum());

	TInt error = aMessage.Write(0,pkgReqId);

	if(error != KErrNone)

		{

		aMessage.Complete(error);

		return;

		}

	RSemaphore semaphore;

	error = semaphore.Open(aMessage, 3, EOwnerThread);

	if(error != KErrNone)

		{

		aMessage.Complete(error);

		return;

		}

	semaphore.Signal();

	semaphore.Close();

	PrivacyRequest(aMessage, sessionId.SessionNum());

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::NewPrivacyRequest() End\n");

	}

void CSuplProxyPrivacySession::RepeatPrivacyRequest(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::RepeatPrivacyRequest() Begin\n");

	PrivacyRequest(aMessage, aMessage.Int0());

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::RepeatPrivacyRequest() End\n");

	}

void CSuplProxyPrivacySession::PrivacyRequest(const RMessage2& aMessage, TInt aRequestId)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::PrivacyRequest() Begin\n");

	CSuplProxyPrivacyRequestInfo* requestInfo = NULL;

	TRAPD(err, requestInfo = CSuplProxyPrivacyRequestInfo::NewL(aMessage));

	if (err != KErrNone)

		{

		// Error creating request info object, complete with the error and return

		aMessage.Complete(err);

		return;

		}

	requestInfo->SetRequestId(aRequestId);

    TLbsExternalRequestInfo2 extRequestInfo;

    TPckg<TLbsExternalRequestInfo2> extRequestInfoPkg(extRequestInfo);

    aMessage.Read(1,extRequestInfoPkg);

    requestInfo->SetRequestInfo(extRequestInfo);

	TLbsNetPosRequestPrivacy netPosRequestPrivacy;

	TPckg<TLbsNetPosRequestPrivacy> netPosRequestPrivacyPkg(netPosRequestPrivacy);

	aMessage.Read(2,netPosRequestPrivacyPkg);

    requestInfo->SetRequestPrivacy(netPosRequestPrivacy);

	requestInfo->SetIsResponseRequired(ETrue);

	requestInfo->SetIsSessionCompleteAutomatic(EFalse);

	requestInfo->SetConvertResponseCode(EFalse);

	if (!IsRequestInfoValid(*requestInfo))

		{

		aMessage.Complete(netPosRequestPrivacy.RequestAction());

		delete requestInfo;

		return;

		}

	iPrivacyProtocol.PrivacyLocationRequest(requestInfo);

	// The message should be completed later in this case

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::PrivacyRequest() End\n");

	}

void CSuplProxyPrivacySession::CompleteRequest(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::CompleteRequest() Begin\n");

	TUint32 requestId(aMessage.Int0());

	TInt reason(aMessage.Int1());

	iPrivacyProtocol.CompletePrivacyRequest(requestId, reason);

	aMessage.Complete(KErrNone);

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::CompleteRequest() End\n");

	}

/**

Validates the data values for a privacy request.

@param aRequestInfo The request data to validate

*/

TBool CSuplProxyPrivacySession::IsRequestInfoValid(const CSuplProxyRequestInfoBase& aRequestInfo)

	{

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::IsRequestInfoValid() Begin\n");

	TBool valid = (aRequestInfo.GetRequestId() >= 1);

	switch (aRequestInfo.Type())

		{

		case CSuplProxyRequestInfoBase::ESuplProxyPrivacyRequestTypeRequest:

			{

			break;

			}

		case CSuplProxyRequestInfoBase::ESuplProxyPrivacyRequestTypeCancel:

			{

			const CCancelSuplProxyPrivacyRequestInfo& cancelInfo = 

				static_cast<const CCancelSuplProxyPrivacyRequestInfo&>(aRequestInfo);

			valid &= (cancelInfo.CancelReason() == KErrCancel

					  || cancelInfo.CancelReason() == KErrTimedOut);

			break;

			}

		default:

			{

			valid = EFalse;

			break;

			}

		}

	LBSLOG(ELogP1, "CSuplProxyPrivacySession::IsRequestInfoValid() End\n");

	return valid;

	}