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

// privacyserver.cpp

// 

//

#include "lbsdevloggermacros.h"

#include "privacysession.h"

#include "privacyrequestinfo.h"

#include "privacyprotocol.h"

#include "EPos_PrivacyServerPanic.h"

#include <lbs/lbsprivacyrequestcommon.h>

/**

Constructor.

@param aProtocol Interface to send privacy requests to.

*/

CPrivacySession::CPrivacySession(MPrivacyProtocol& aProtocol, 

									 TLbsProxyApiType aApiType) : 

	iProtocol(aProtocol),

	iApiType(aApiType)

	{

	LBSLOG(ELogP1, "CPrivacySession::CPrivacySession()\n");

	}

/**

Destructor.

*/

CPrivacySession::~CPrivacySession()

	{

	LBSLOG(ELogP1, "CPrivacySession::~CPrivacySession()\n");

	}

/**

Called when the session is created.

*/

void CPrivacySession::CreateL()

	{

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

	Server().IncSessionCount(iApiType);

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

	}

/**

Called when a message is received for this session.

@param aMessage The message from the client.

*/

void CPrivacySession::ServiceL(const RMessage2& aMessage)

	{

	LBSLOG(ELogP1, "CPrivacySession::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, "CPrivacySession::ServiceL() End\n");

	}

/**

Called when the session disconnects.

@param aMessage The message from the client.

*/

void CPrivacySession::Disconnect(const RMessage2& aMessage)

	{

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

	iProtocol.SessionDisconnected(this);

	Server().DecSessionCount(iApiType);

	CSession2::Disconnect(aMessage);

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

	}

/**

Get a reference to the server for this session.

@return A reference to the CPrivacyServer.

*/

CPrivacyServer& CPrivacySession::Server()

	{

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

	}

/**

Cancel a verification request.

@param aMessage The message from the client.

*/

void CPrivacySession::CancelVerifyLocationRequest(const RMessage2& aMessage)

	{

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

	CCancelPrivacyRequestInfo* cancelInfo = NULL;

	TRAPD(err, cancelInfo = CCancelPrivacyRequestInfo::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);

	iProtocol.CancelVerifyLocationRequest(cancelInfo);

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

	}

/**

Submit a notification request.

@param aMessage The message from the client.

*/

void CPrivacySession::NotifyLocationRequest(const RMessage2& aMessage)

	{

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

	TLbsNetSessionId sessionId;

	iProtocol.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

	CPrivacyRequestInfo* requestInfo = NULL;

	TRAPD(err, requestInfo = CPrivacyRequestInfo::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;

		}

	iProtocol.NotifyLocationRequest(requestInfo);

	aMessage.Complete(KErrNone);

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

	}

/**

Submit a notification timeout request.

@param aMessage The message from the client.

*/

void CPrivacySession::NotifyVerificationTimeout(const RMessage2& aMessage)

	{

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

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

	CPrivacyRequestInfo* requestInfo = NULL;

	TRAPD(err, requestInfo = CPrivacyRequestInfo::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;

		}

	iProtocol.NotifyVerificationTimeout(requestInfo);

	aMessage.Complete(KErrNone);

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

	}

/**

Submit a verify location request.

@param aMessage The message from the client.

*/

void CPrivacySession::VerifyLocationRequest(const RMessage2& aMessage)

	{

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

	TLbsNetSessionId sessionId;

	iProtocol.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();

	CPrivacyRequestInfo* requestInfo = NULL;

	TRAPD(err, requestInfo = CPrivacyRequestInfo::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;

		}

	iProtocol.VerifyLocationRequest(requestInfo);

	// The message should be completed later in this case

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

	}

void CPrivacySession::NewPrivacyRequest(const RMessage2& aMessage)

	{

	TLbsNetSessionId sessionId;

	iProtocol.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());

	}

void CPrivacySession::RepeatPrivacyRequest(const RMessage2& aMessage)

	{

	PrivacyRequest(aMessage, aMessage.Int0());

	}

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

	{

	CPrivacyRequestInfo* requestInfo = NULL;

	TRAPD(err, requestInfo = CPrivacyRequestInfo::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;

		}

	iProtocol.PrivacyLocationRequest(requestInfo);

	// The message should be completed later in this case

	}

void CPrivacySession::CompleteRequest(const RMessage2& aMessage)

	{

	TUint32 requestId(aMessage.Int0());

	TInt reason(aMessage.Int1());

	iProtocol.CompletePrivacyRequest(requestId, reason);

	aMessage.Complete(KErrNone);

	}

/**

Validates the data values for a privacy request.

@param aRequestInfo The request data to validate

*/

TBool CPrivacySession::IsRequestInfoValid(const CRequestInfoBase& aRequestInfo)

	{

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

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

	switch (aRequestInfo.Type())

		{

		case CRequestInfoBase::EPrivacyRequestTypeRequest:

			{

			break;

			}

		case CRequestInfoBase::EPrivacyRequestTypeCancel:

			{

			const CCancelPrivacyRequestInfo& cancelInfo = 

				static_cast<const CCancelPrivacyRequestInfo&>(aRequestInfo);

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

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

			break;

			}

		default:

			{

			valid = EFalse;

			break;

			}

		}

	return valid;

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

	}