// 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:
// lbsnrhserver.cpp
// server side exmaple of how to use the abstract server framework
// 
//

#include <e32debug.h>
#include <lbs/lbslocclasstypes.h>
#include "lbsnrhprivacycontrollerserver.h"
#include "opensessionparams.h"
#include "lbsnrhmessageenums.h"
#include "lbsnrhserverdata.h"
#include "nrhpanic.h"

TPositionInfoClassTypeFixer::TPositionInfoClassTypeFixer(const TPositionInfo& aPositionInfo) :
TPositionInfo(aPositionInfo)
  	{
  	iPosClassType = EPositionInfoClass;
  	iPosClassSize = sizeof(TPositionInfo);
  	}

CNrhPrivacyServerSubsession::CNrhPrivacyServerSubsession() :
	iPendingPrivacyRequests(1)
	{
	}

CNrhPrivacyServerSubsession::~CNrhPrivacyServerSubsession()
	{
	// cancel ANY outstanding requests with KErrServerTerminated
	// or some other error code to indicate that the session has been closed
	// early
	if(!iPrivacyControllerMessage.IsNull())
		{
		iPrivacyControllerMessage.Complete(KErrServerTerminated); 	
		}

	iPendingMessage.Reset();
	iPendingPrivacyRequests.Reset();
	iPendingLocationUpdates.Reset();
	iPendingSessionCompletes.Reset();
	CloseSubSession();
	}

CNrhPrivacyServerSubsession* CNrhPrivacyServerSubsession::NewL()
	{
	CNrhPrivacyServerSubsession* self = new (ELeave) CNrhPrivacyServerSubsession;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

void CNrhPrivacyServerSubsession::ConstructL()
	{
	}

void CNrhPrivacyServerSubsession::DispatchL(const RMessage2& aMessage)
	{
	switch(aMessage.Function())
		{
		case ENrhPrivacyControllerRegister:
			SetClientReady(aMessage);
			break;
			
		case ENrhPrivacyControllerCancelRegister:
			CancelClientReady(aMessage);
			break;
			
		case ENrhPrivacyControllerResponse:
			HandlePrivacyResponse(aMessage);
			break;
			
		case ENrhPrivacyControllerCancel:
			HandlePrivacyCancel(aMessage);
			break;
		}
	}
	
void CNrhPrivacyServerSubsession::DispatchError(const RMessage2& /*aMessage*/, TInt /*aError*/)
	{
	// errors from DispatchL end up in here
	}
	
void CNrhPrivacyServerSubsession::CreateSubSessionL(const RMessage2& aMessage, 
									const CSecureServerBase* aServer)
	{	
	// Get hold of something for this subsession 
	// to pass on its messages (respond/cancel privacy request) to	
	iNrhServer = reinterpret_cast<const CNrhServer*>(aServer);

	// Check the version of the MLbsPrivacyObserver is supported
	User::LeaveIfError(CheckPrivacyObserverVersion(aMessage));

	// Let the privacyhandler know where it should be passing its messages
	// (privacy request, location update, session complete) to.
	iNrhServer->PrivacyObserver()->SetServerObserver(this);
	}
	
void CNrhPrivacyServerSubsession::CloseSubSession()
	{
	if (iNrhServer->PrivacyObserver() != NULL)
		{
		iNrhServer->PrivacyObserver()->SetServerObserver(NULL);
		}
	}
	
void CNrhPrivacyServerSubsession::VirtualRelease()
	{	
	//delete ourselves - can be called on a via CS on a leave
	delete this; // we are allocated via the GetImpl above, and a handle to "us" is returned
	}
	
void CNrhPrivacyServerSubsession::SetClientReady(const RMessage2& aMessage)
	{
	iPrivacyControllerMessage = aMessage;
	
	/* 
	 * See whether there are any messages which have been received since 
	 * sending the last one on to the client
	 */
	TInt pendingMessages = iPendingMessage.Count();
	if(pendingMessages)
		{
		TNrhServerMessageType messageType = iPendingMessage[0];
		iPendingMessage.Remove(0);
		switch(messageType)
			{
			case ENrhServerPrivacyRequest:
				{
				TPrivacyRequestParams privacyRequestParams = 
												iPendingPrivacyRequests[0];
		
				TPrivacyRequestParamsPckgC privacyRequestParamsPckg(privacyRequestParams);
				MessageUtils::Write(iPrivacyControllerMessage, 
							EPrivacyRequestParams, 
							privacyRequestParamsPckg);
				iPrivacyControllerMessage.Complete(ENrhServerPrivacyRequest);
				iPendingPrivacyRequests.Delete(0);
				break;
				}
				
			case ENrhServerLocationUpdate:
				{
				TLocationUpdateParams locationUpdateParams;
				locationUpdateParams.iSessionId = iPendingLocationUpdates[0].iSessionId;
								
				//It is necessary to update tha class type and size to TPositionInfo class type and size
				//in case if the pos update is of TPositionCourseInfo, TPositionSatelliteInfo, 
				//TPositionExtendedSatelliteInfo or HPositionGenericInfo class type.
				// Because only TPositionInfo part is passed to the LbsPrivacyController.
				TPositionInfoClassTypeFixer posFixer = iPendingLocationUpdates[0].iPositionInfo;  
				locationUpdateParams.iPositionInfo = posFixer;

				TLocationUpdateParamsPckgC locationUpdateParamsPckg(locationUpdateParams);
		
				MessageUtils::Write(iPrivacyControllerMessage, 
							ELocationUpdateParams, 
							locationUpdateParamsPckg);
				iPrivacyControllerMessage.Complete(ENrhServerLocationUpdate);
				iPendingLocationUpdates.Remove(0);
				break;
				}
				
			case ENrhServerLbsSessionComplete:
				{
				TLbsSessionCompleteParams lbsSessionCompleteParams = 
												iPendingSessionCompletes[0];
				TLbsSessionCompleteParamsPckgC lbsSessionCompleteParamsPckg(lbsSessionCompleteParams);
		
				MessageUtils::Write(iPrivacyControllerMessage, 
							ELbsSessionCompleteParams, 
							lbsSessionCompleteParamsPckg);
				iPrivacyControllerMessage.Complete(ENrhServerLbsSessionComplete);
				iPendingSessionCompletes.Remove(0);
				break;
				}
			}
		}
	}
	
void CNrhPrivacyServerSubsession::CancelClientReady(const RMessage2& aMessage)
	{
	// Cancel the outstanding request as well.
	if(!iPrivacyControllerMessage.IsNull())
		{
		iPrivacyControllerMessage.Complete(KErrNone); 	
		}

	// Complete this message (the cancel request)
	aMessage.Complete(KErrNone);
	}
	
void CNrhPrivacyServerSubsession::HandlePrivacyResponse(const RMessage2& aMessage)
	{
	
	// Get the data from the IPC message
	TPrivacyResponseParams privacyResponseParams;	
	TPckg<TPrivacyResponseParams> privacyResponseParamsBuf(privacyResponseParams);

	MessageUtils::Read(aMessage, 0, privacyResponseParamsBuf);

	TLbsNetworkEnumInt::TLbsPrivacyResponseInt response;
	
	if(privacyResponseParams.iResult == CLbsPrivacyController::ERequestAccepted)
		{
		response = TLbsNetworkEnumInt::EPrivacyResponseAccepted;
		}
	else
		{
		response = TLbsNetworkEnumInt::EPrivacyResponseRejected;
		}

	iNrhServer->PrivacyObserver()->OnRespondNetworkLocationRequest(privacyResponseParams.iSessionId,
												response, KErrNone);

	aMessage.Complete(KErrNone);
	
	}
	
void CNrhPrivacyServerSubsession::HandlePrivacyCancel(const RMessage2& aMessage)
	{

	// Get the data from the IPC message
	TPrivacyCancelParams privacyCancelParams;	
	TPckg<TPrivacyCancelParams> privacyCancelParamsBuf(privacyCancelParams);

	MessageUtils::Read(aMessage, 0, privacyCancelParamsBuf);

	iNrhServer->PrivacyObserver()->OnCancelNetworkLocationRequest(privacyCancelParams.iSessionId);

	aMessage.Complete(KErrNone);
	
	}
void CNrhPrivacyServerSubsession::ProcessNetworkLocationRequest(TLbsNetSessionIdInt aSessionId, 
																const TLbsNetworkEnumInt::TLbsNetProtocolServiceInt /*aSessionType*/,
                                         						const TLbsExternalRequestInfo&  aRequestInfo, 
                       											const TLbsNetPosRequestPrivacyInt& aNetPosRequestPrivacy,
                       											TBool /*aIsEmergency*/)
	{
	__ASSERT_DEBUG((aRequestInfo.ClassType() == EExternalRequestInfoClass) 
				   || (aRequestInfo.ClassType() == 
						(EExternalRequestInfoClass | EExternalRequestInfoClass2)), 
				   Panic(ENrhPanicInvalidExternalRequestInfoType));
	
	TPrivacyRequestParams privacyRequestData;
	privacyRequestData.iSessionId = aSessionId;
	Mem::Copy(&privacyRequestData.iRequestInfo,
			  &aRequestInfo,
			  aRequestInfo.ClassSize());
	privacyRequestData.iRequestPrivacy = aNetPosRequestPrivacy;

	if(!iPrivacyControllerMessage.IsNull())
		{
		TPrivacyRequestParamsPckgC privacyRequestDataPckg(privacyRequestData);
		MessageUtils::Write(iPrivacyControllerMessage, 
							EPrivacyRequestParams, 
							privacyRequestDataPckg);
		iPrivacyControllerMessage.Complete(ENrhServerPrivacyRequest); 	
		}
	else
		{
		TRAPD(err, iPendingPrivacyRequests.AppendL(privacyRequestData));
		// No point flagging a pending message if we didn't manage to store it
		if(err == KErrNone)
			{
			err = iPendingMessage.Append(ENrhServerPrivacyRequest);
			}
		}

	}
	
void CNrhPrivacyServerSubsession::ProcessNetworkPositionUpdate(TLbsNetSessionIdInt aSessionId, 
                              const TPositionInfo& aPositionInfo)
	{
	//It is necessary to update tha class type and size to TPositionInfo class type and size
	//in case if the pos update is of TPositionCourseInfo, TPositionSatelliteInfo, 
	//or HPositionGenericInfo class type. Because only TPositionInfo part is 
	//passed to the LbsPrivacyController.
	TLocationUpdateParams locationUpdateParams;
	locationUpdateParams.iSessionId = aSessionId;
	TPositionInfoClassTypeFixer posFixer = aPositionInfo;  
	locationUpdateParams.iPositionInfo = posFixer;
    
	if(!iPrivacyControllerMessage.IsNull())
		{
		TLocationUpdateParamsPckgC locationUpdateParamsPckg(locationUpdateParams);
		MessageUtils::Write(iPrivacyControllerMessage, 
							ELocationUpdateParams, 
							locationUpdateParamsPckg);
		iPrivacyControllerMessage.Complete(ENrhServerLocationUpdate); 	
		}
	else
		{
		TInt err = iPendingLocationUpdates.Append(locationUpdateParams);
		// No point flagging a pending message if we didn't manage to store it
		if(err == KErrNone)
			{
			err = iPendingMessage.Append(ENrhServerLocationUpdate);
			}
		}
	}
	
	
void CNrhPrivacyServerSubsession::ProcessRequestComplete(TLbsNetSessionIdInt aSessionId, 
                                TInt aReason)
	{


	TLbsSessionCompleteParams lbsSessionCompleteParams;
	lbsSessionCompleteParams.iSessionId = aSessionId;
	lbsSessionCompleteParams.iReason = aReason;

	if(!iPrivacyControllerMessage.IsNull())
		{
		TLbsSessionCompleteParamsPckgC lbsSessionCompleteParamsPckg(lbsSessionCompleteParams);
		MessageUtils::Write(iPrivacyControllerMessage, 
							ELbsSessionCompleteParams, 
							lbsSessionCompleteParamsPckg);
		iPrivacyControllerMessage.Complete(ENrhServerLbsSessionComplete); 	
		}
	else
		{
		TInt err = iPendingSessionCompletes.Append(lbsSessionCompleteParams);
		// No point flagging a pending message if we didn't manage to store it
		if(err == KErrNone)
			{
			err = iPendingMessage.Append(ENrhServerLbsSessionComplete);
			}
		}
	}

/** Check the version of MLbsPrivacyObserver the client is using is supported. 
*/
TInt CNrhPrivacyServerSubsession::CheckPrivacyObserverVersion(const RMessage2& aMessage)
	{
	TInt result = KErrNone;
	
	TNrhPrivacyControllerData data;
	TPckg<TNrhPrivacyControllerData> dataPckg(data);
	MessageUtils::Read(aMessage, 1, dataPckg);

	if (data.iVersion.iMajor == KLbsPrivacyObserverVersionMajor
		&& data.iVersion.iMinor == KLbsPrivacyObserverVersionMinor)
		{
		result = KErrNone;
		}
	else if (data.iVersion.iMajor == KLbsPrivacyObserverVersion2Major
			 && data.iVersion.iMinor == KLbsPrivacyObserverVersion2Minor)
		{
#if defined(SYMBIAN_LOCATION_PRIVACY_V2)
		result = KErrNone;
#else
		result = KErrNotSupported;
#endif // SYMBIAN_LOCATION_PRIVACY_V2
		}
	else
		{
		// Unrecognised version; so return KErrNotSupported
		result = KErrNotSupported;
		}
	
	return result;
	}