// 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:
// Client side implementation for the LbsX3P Api.
// 
//

#include <e32base.h>
#include <e32debug.h>
#include <lbspositioninfo.h>
#include "lbsnrhserverdata.h"
#include "LbsX3PImpl.h"
#include "lbsprocessuiddefs.h"
#include "messageutils.h"
#include "lbsx3pdata.h"
#include "lbsnrhmessageenums.h"
#include "lbssystemcontroller.h"


//
// RNrhServer
//

/* The X3P Implementation hides the details of the 
 * Privacy Controller from the class CLbsPrivacyController, which uses only the
 * published API.
 *
 * The privacy comntroller is implemented here as a client of the Network
 * Request Handler, which includes a server to handle requests from this 
 * component.
 *
 * Generic operation on thet client side is implemented by the
 * code in lbsloccommon\serverframework.
  */
RNrhServer::RNrhServer()
	{
	// nothing to do
	}
 	
RNrhServer::~RNrhServer()
	{
	// nothing to do
	}

TVersion RNrhServer::Version()
	{
	return TVersion(KNrhServerMajorVersionNumber,
					KNrhServerMinorVersionNumber,
					KNrhServerBuildVersionNumber);
	}

TInt RNrhServer::StartServer(TServerStartParams& /*aParams*/)
	{
	// Start LBS from LbsRoot    
    TRAPD(err, StartLbsL());
    return (err);
	}

void RNrhServer::StartLbsL()
	{
    RLbsSystemController systemController;
    RProcess process;
    CleanupClosePushL(process);
	systemController.OpenL(process.SecureId());
	CleanupClosePushL(systemController);
	
	TInt startErr = systemController.RequestSystemStartup();
	if (startErr != ELbsStartupSuccess)
		{
		User::Leave(KErrCouldNotConnect);
		}
	
	CleanupStack::PopAndDestroy(2, &process);
	}

//
// RNrhSession
//

RNrhSession::RNrhSession() :
	iTransmittedPosInfoPtr(NULL, 0),
	iTransmitPositionParamsPtr(NULL, 0),
	iReferencePosInfoPtr(NULL, 0),
	iReferencePositionParamsPtr(NULL, 0)
	{
	// nothing to do
	}
	
RNrhSession::~RNrhSession()
	{
	// nothing to do
	}

void RNrhSession::TransmitPosition(const TDesC& aDestinationId,
								   TUint aTransmitPriority,
								   TRequestStatus& aStatus, 
								   TPositionInfo& aTransmittedPosInfo)
	{	
	// iDestinationId is too big to fit in the buffer;
	// complete the request early with an error code	
	if (aDestinationId.Length() > iTransmitPositionParams.iDestinationId.MaxLength())
		{
		TRequestStatus* status = &aStatus;
		User::RequestComplete(status, KErrTooBig);
		}
	
	iTransmitPositionParams.iDestinationId = aDestinationId;
	iTransmitPositionParams.iPriority = aTransmitPriority;
	iTransmitPositionParams.iPositionInfoClassType = aTransmittedPosInfo.PositionClassType();
	iTransmitPositionParams.iPositionInfoClassSize = aTransmittedPosInfo.PositionClassSize();
	
	iTransmitPositionParamsPtr.Set(reinterpret_cast<TUint8*>(&iTransmitPositionParams),
								   sizeof(iTransmitPositionParams),
								   sizeof(iTransmitPositionParams));
	iTransmittedPosInfoPtr.Set(reinterpret_cast<TUint8*>(&aTransmittedPosInfo), 
							   aTransmittedPosInfo.PositionClassSize(),
							   aTransmittedPosInfo.PositionClassSize());
	TIpcArgs args(&iTransmitPositionParamsPtr, &iTransmittedPosInfoPtr);
	SendReceive(EX3pTransmitPosition, args, aStatus);
	}

void RNrhSession::TransmitPosition(const TDesC& aDestinationId,TUint aTransmitPriority,
						                 TRequestStatus& aRefPosStatus, TPositionInfo& aRefPosInfo,
						  TRequestStatus& aTransmittedPosStatus, TPositionInfo& aTransmittedPosInfo)
	{
	// iDestinationId is too big to fit in the buffer;
	// complete the request early with an error code	
	if (aDestinationId.Length() > iTransmitPositionParams.iDestinationId.MaxLength())
		{
		TRequestStatus* refStatus = &aRefPosStatus;
		TRequestStatus* transmittedStatus = &aTransmittedPosStatus;
		User::RequestComplete(refStatus, KErrTooBig);
		User::RequestComplete(transmittedStatus, KErrTooBig);
		}
		
	ReportReferenceLocation(aRefPosStatus, aRefPosInfo);
	TransmitPosition(aDestinationId, aTransmitPriority,
					 aTransmittedPosStatus, aTransmittedPosInfo);
	}

void RNrhSession::ReportReferenceLocation(TRequestStatus& aRefPosStatus, TPositionInfo& aReferencePosInfo)
	{

	iReferencePositionParams.iPositionInfoClassType = aReferencePosInfo.PositionClassType();
	iReferencePositionParams.iPositionInfoClassSize = aReferencePosInfo.PositionClassSize();
	
	iReferencePositionParamsPtr.Set(reinterpret_cast<TUint8*>(&iReferencePositionParams),
								   sizeof(iReferencePositionParams),
								   sizeof(iReferencePositionParams));
								   
	iReferencePosInfoPtr.Set(reinterpret_cast<TUint8*>(&aReferencePosInfo), 
							   aReferencePosInfo.PositionClassSize(),
							   aReferencePosInfo.PositionClassSize());
	TIpcArgs args(&iReferencePositionParamsPtr, &iReferencePosInfoPtr);
	SendReceive(EX3pReportReferenceLocation , args, aRefPosStatus);
	}

void RNrhSession::CancelTransmitPosition()
	{
	TIpcArgs args;
	SendReceive(EX3pCancelTransmitPosition, args);
	}

TInt RNrhSession::SetTransmitOptions(const TLbsTransmitPositionOptions& aTransmitOptions)
	{
	TPckgC<TLbsTransmitPositionOptions> optionsPckg(aTransmitOptions);
	TIpcArgs args(&optionsPckg);
	return (SendReceive(EX3pSetTransmitOptions, args));
	}
	
TInt RNrhSession::GetTransmitOptions(TLbsTransmitPositionOptions& aTransmitOptions) const
	{
	TPckg<TLbsTransmitPositionOptions> optionsPckg(aTransmitOptions);
	TIpcArgs args(&optionsPckg);
	return (SendReceive(EX3pGetTransmitOptions, args));
	}

//
// CLbsTransmitPositionServerImpl
//

CLbsTransmitPositionServerImpl::CLbsTransmitPositionServerImpl()
	{
	}
		
CLbsTransmitPositionServerImpl::~CLbsTransmitPositionServerImpl()
	{
	iServer.Close();
	}
	
CLbsTransmitPositionServerImpl* CLbsTransmitPositionServerImpl::NewL()
	{
	CLbsTransmitPositionServerImpl* self = new (ELeave) CLbsTransmitPositionServerImpl;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

void CLbsTransmitPositionServerImpl::ConstructL()
	{
	/**
	 * See the ServerFramework code for the meaning of this code
	 */
	iParams.SetServerFileName(KNrhServerFileName);
	iParams.SetServerName(KNrhServerName);
	iParams.SetNumberOfServerSlots(-1); // Use messages from the global pool
	iParams.SetServerUids(KNullUid, KNullUid, KLbsNetRequestHandlerUid);
	
	User::LeaveIfError(iServer.Connect(iParams));
	}

RNrhServer& CLbsTransmitPositionServerImpl::Server()
	{
	return iServer;
	}

//
// CLbsTransmitPositionImpl
//

CLbsTransmitPositionImpl::CLbsTransmitPositionImpl()
	{
	
	}
	
CLbsTransmitPositionImpl::~CLbsTransmitPositionImpl()
	{
	iSession.Close();
	}

CLbsTransmitPositionImpl* CLbsTransmitPositionImpl::NewL(RLbsTransmitPositionServer& aServer)
	{
	CLbsTransmitPositionImpl* self = new (ELeave) CLbsTransmitPositionImpl;
	CleanupStack::PushL(self);
	self->ConstructL(aServer);
	CleanupStack::Pop(self);
	return self;	
	}

void CLbsTransmitPositionImpl::ConstructL(RLbsTransmitPositionServer& aServer)
	{
	TNrhX3PData data;
	TNrhSubSessionType type(ENrhSubSessionX3P);
	User::LeaveIfError(iSession.Open<TNrhSubSessionType, TNrhX3PData>(
						aServer.Impl().Server(), 
						type,
						data));
	}

void CLbsTransmitPositionImpl::TransmitPosition(const TDesC& aDestinationID,
												TUint aTransmitPriority, 
												TRequestStatus& aTransmittedPosStatus, 
												TPositionInfo& aTransmittedPosInfo)
	{
	iSession.TransmitPosition(aDestinationID, aTransmitPriority,
							  aTransmittedPosStatus, aTransmittedPosInfo);
	}

void CLbsTransmitPositionImpl::TransmitPosition(const TDesC& aDestinationID,TUint aTransmitPriority,
						                 TRequestStatus& aRefPosStatus, TPositionInfo& aRefPosInfo,
						  TRequestStatus& aTransmittedPosStatus, TPositionInfo& aTransmittedPosInfo)
	{
	iSession.TransmitPosition(aDestinationID, aTransmitPriority, aRefPosStatus,aRefPosInfo,
						      aTransmittedPosStatus, aTransmittedPosInfo);
	}

void CLbsTransmitPositionImpl::CancelTransmitPosition()
	{
	iSession.CancelTransmitPosition();
	}

TInt CLbsTransmitPositionImpl::SetTransmitOptions(const TLbsTransmitPositionOptions& aTransmitOptions)
	{
	return (iSession.SetTransmitOptions(aTransmitOptions));
	}
	
TInt CLbsTransmitPositionImpl::GetTransmitOptions(TLbsTransmitPositionOptions& aTransmitOptions) const
	{
	return (iSession.GetTransmitOptions(aTransmitOptions));
	}