diff -r 000000000000 -r 9cfd9a3ee49c locationrequestmgmt/networkrequesthandler/LbsX3P/LbsX3PApi/src/LbsX3PImpl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/locationrequestmgmt/networkrequesthandler/LbsX3P/LbsX3PApi/src/LbsX3PImpl.cpp	Tue Feb 02 01:50:39 2010 +0200
@@ -0,0 +1,293 @@
+// 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));
+	}
+
+