diff -r 000000000000 -r 9cfd9a3ee49c networkprotocolmodules/networkprotocolmodule/LbsNetSim/src/lbsnetsimtest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkprotocolmodules/networkprotocolmodule/LbsNetSim/src/lbsnetsimtest.cpp Tue Feb 02 01:50:39 2010 +0200 @@ -0,0 +1,842 @@ +// 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: +// + +#include "lbsnetsim.h" +#include "lbsnetsimtest.h" +#include "lbsnetsimtestobserver.h" + +#include +#include + +/** +Constructor +*/ +EXPORT_C RLbsNetSimTest::RLbsNetSimTest() : + iObserver(NULL), iNotificationConnect(NULL), iNotificationDisconnect(NULL), + iNotificationRegisterLcsMoLr(NULL), iNotificationReleaseLcsMoLr(NULL), + iNotificationMeasurementReport(NULL), + iNotificationMeasurementReportRequestMoreAssitanceData(NULL), iNotificationMeasurementReportControlFailure(NULL), + iNotificationMeasurementControlLocation(NULL), iNotificationFacilityLcsMoLrResult(NULL), + iMessageReleaseLcsLocationNotification(NULL), iMessageStartNetworkLocationRequest(NULL) + { + } + + +/** +Destructor +*/ +EXPORT_C RLbsNetSimTest::~RLbsNetSimTest() + { + } + +/** +Connect to the server + +@param aObserver observer to use for callbacks +*/ +EXPORT_C TInt RLbsNetSimTest::ConnectL(MLbsNetSimTestObserver* aObserver) + { + TInt err = KErrNone; + + // Attempt to start the server and create a session + for (TInt x = 0; ((x < 2) && (err == KErrNone)); x++) + { + err = CreateSession(KLbsNetSimServerName, TVersion(0,0,0)); + if (err == KErrNone) + { + break; // We have a session + } + + // Cant create a session + if ((err == KErrNotFound) || (err == KErrServerTerminated)) + { + // We need to start the server + err = StartServer(); + } // if + } // for + + // Leave if we have no session + if (err == KErrNone) + { + TIpcArgs args(ETestHandler); + err = SendReceive(EInitialise, args); + + // Again if we cant initialise then leave + if (err == KErrNone) + { + iObserver = aObserver; + if (iObserver != NULL) + { + // Create callback handlers + iNotificationConnect = new(ELeave) CNotificationConnect(this, iObserver); + iNotificationDisconnect = new(ELeave) CNotificationDisconnect(this, iObserver); + iNotificationRegisterLcsMoLr = new(ELeave) CNotificationRegisterLcsMoLr(this, iObserver); + iNotificationReleaseLcsMoLr = new(ELeave) CNotificationReleaseLcsMoLr(this, iObserver); + iMessageReleaseLcsLocationNotification = new(ELeave) CMessageReleaseLcsLocationNotification(this, iObserver); + iNotificationMeasurementReport = new(ELeave) CNotificationMeasurementReport(this, iObserver); + iNotificationMeasurementReportRequestMoreAssitanceData = new(ELeave) CNotificationMeasurementReportRequestMoreAssitanceData(this, iObserver); + iNotificationMeasurementReportControlFailure = new(ELeave) CNotificationMeasurementReportControlFailure(this, iObserver); + iNotificationMeasurementControlLocation = CNotificationMeasurementControlLocation::NewL(this, iObserver); + iNotificationFacilityLcsMoLrResult = new(ELeave) CNotificationFacilityLcsMoLrResult(this, iObserver); + iMessageStartNetworkLocationRequest = new(ELeave) CMessageStartNetworkLocationRequest(this, iObserver); + + // Set-up property for step mode + err = RProperty::Define(TUid::Uid(KLbsNetSimClient), KLbsStepModeKey, RProperty::EInt, + ECapability_None, ECapability_None); + + if (err == KErrAlreadyExists) + err = KErrNone; //we have already setup NetSim and property before + } + } + } + + return err; + } + + +/** +Close the connection to the server +*/ +EXPORT_C void RLbsNetSimTest::Close() + { + // Cleanup here as they are created in the connect + delete iNotificationConnect; + delete iNotificationDisconnect; + delete iNotificationRegisterLcsMoLr; + delete iNotificationReleaseLcsMoLr; + delete iMessageReleaseLcsLocationNotification; + delete iNotificationMeasurementReport; + delete iNotificationMeasurementReportRequestMoreAssitanceData; + delete iNotificationMeasurementReportControlFailure; + delete iNotificationMeasurementControlLocation; + delete iNotificationFacilityLcsMoLrResult; + delete iMessageStartNetworkLocationRequest; + + RSessionBase::Close(); + } + + +/** +Set the reference location to use + +The reference location is passed to the assitance data supply module when +retrieving assistance data. + +@param aLocation the reference location +*/ +EXPORT_C TBool RLbsNetSimTest::SetReferenceLocation(TPosition& aPosition) + { + TPckg positionPkg(aPosition); + + TIpcArgs args(&positionPkg); + return (SendReceive(ETSetReferenceLocation, args) == KErrNone); + } + + +/** +Set the reference location to use + +The reference location is passed to the assitance data supply module when +retrieving assistance data. + +@param aLocation the reference location +*/ +EXPORT_C TBool RLbsNetSimTest::SetReferenceLocation(TDesC8& aLocation) + { + TIpcArgs args(&aLocation); + return (SendReceive(ETSetReferenceLocationData, args) == KErrNone); + } + + +/** +Set the time taken to respond to a request + +@param aTime the time in milliseconds to wait before responding +@param aSticky continue using this delay until further notice +*/ +EXPORT_C TBool RLbsNetSimTest::SetResponseTime(TInt32 aTime, TBool aSticky) + { + TIpcArgs args(aTime, aSticky); + return (SendReceive(ETSetResponseTime, args) == KErrNone); + } + + +/** +Set the error to respond to a request + +@param aError any error value +@param aSticky continue using this delay until further notice +*/ +EXPORT_C TBool RLbsNetSimTest::SetResponseError(TInt32 aError, TBool aSticky) + { + TIpcArgs args(aError, aSticky); + return (SendReceive(ETSetResponseError, args) == KErrNone); + } + + +/** +Set the default assitance data returned + +@param aFilter the filter +*/ +EXPORT_C TBool RLbsNetSimTest::SetDefaultAssitanceDataFilter(TLbsAssistanceDataGroup& aFilter) + { + TPckg filterPkg(aFilter); + TIpcArgs args(&filterPkg); + return (SendReceive(ETSetDefaultAssitanceDataFilter, args) == KErrNone); + } + + +/** +Set the default assitance data returned if more assitance data is required + +@param aFilter the filter +*/ +EXPORT_C TBool RLbsNetSimTest::SetMoreAssitanceDataFilter(TLbsAssistanceDataGroup& aFilter) + { + TPckg filterPkg(aFilter); + TIpcArgs args(&filterPkg); + return (SendReceive(ETSetMoreDefaultAssitanceDataFilter, args) == KErrNone); + } + + +/** +Clear the filters back to there default states +*/ +EXPORT_C TBool RLbsNetSimTest::ClearAssistanceDataFilters() + { + return (SendReceive(ETClearAssitanceDataFilters) == KErrNone); + } + + +/** +Select which assitance data provider to use + +@param aProvider the TUid of the provider to use +*/ +EXPORT_C TBool RLbsNetSimTest::SetAssistanceDataProvider(TUid aProvider) + { + + TIpcArgs args(aProvider.iUid); + return (SendReceive(ETSetAssistanceDataProvider, args) == KErrNone); + } + + +/** +Set the emergeny status of the phone + +@param aEmergency ETrue if the phone should be in emergeny status +*/ +EXPORT_C TBool RLbsNetSimTest::SetEmergenyStatus(TBool aEmergency) + { + TIpcArgs args(aEmergency); + return (SendReceive(ETSetEmergenyStatus, args) == KErrNone); + } + + +/** +Set the roaming status of the phone + +@param aRoaming ETrue if the phone should be in roaming status +*/ +EXPORT_C TBool RLbsNetSimTest::SetRoamingStatus(TBool aRoaming) + { + TIpcArgs args(aRoaming); + return (SendReceive(ETSetRoamingStatus, args) == KErrNone); + } + + +/** +Set the quality + +@param aQuality The quality of the data +*/ +EXPORT_C TBool RLbsNetSimTest::SetQuality(TLbsNetPosRequestQuality& aQuality) + { + TPckg qualityPkg(aQuality); + TIpcArgs args(&qualityPkg); + return (SendReceive(ETSetRequestQuality, args) == KErrNone); + } + +EXPORT_C TBool RLbsNetSimTest::SendResetAssistanceData(TLbsAssistanceDataGroup aMask) + { + TIpcArgs args(aMask); + return (SendReceive(ETSendResetAssistanceData, args) == KErrNone); + } + + + +/** +Start a network privacy request + +@param aType +@param aRequest +*/ +EXPORT_C void RLbsNetSimTest::StartNetworkPrivacyRequest(TLbsNetPosRequestPrivacy aType, + TLbsExternalRequestInfo& aRequest) + { + if (iObserver != NULL) + { + iMessageReleaseLcsLocationNotification->Send(aType, aRequest); + } + } + + +/** +Cancel an outstanding network privacy request + + +*/ +EXPORT_C void RLbsNetSimTest::CancelNetworkPrivacyRequest() + { + if (iObserver != NULL) + { + iMessageReleaseLcsLocationNotification->Cancel(); + } + } + + +/** +Start a network location request +*/ +EXPORT_C void RLbsNetSimTest::StartNetworkLocationRequest() + { + if (iObserver != NULL) + { + iMessageStartNetworkLocationRequest->Send(); + } + } + + +/** +Cancels an outstanding network location request + +*/ +EXPORT_C void RLbsNetSimTest::CancelNetworkLocationRequest() + { + if (iObserver != NULL) + { + iMessageStartNetworkLocationRequest->Cancel(); + } + } + + +/** +Enable the simulators step mode + +@param aStepMode ETrue to enter step mode +*/ +EXPORT_C TBool RLbsNetSimTest::SetStepMode(TBool aStepMode) + { + if (iObserver != NULL) + { + TIpcArgs args(aStepMode); + return (SendReceive(ETSetStepMode, args) == KErrNone); + } + else + { + return EFalse; + } + } + + +/** +Enable the simulator to peform the next step + +@param aError The error to use, KErrNone for normal behaviour + +*/ +EXPORT_C TBool RLbsNetSimTest::Next(TInt aError) + { + if (iObserver != NULL) + { + RProperty::Set(TUid::Uid(KLbsNetSimClient), KLbsStepModeKey, aError); + + return ETrue; + } + else + { + return EFalse; + } + } + + +// +// Private methods + +/** +*/ +TInt RLbsNetSimTest::StartServer() + { + RProcess server; + + // Create the process/server + TInt err = server.Create(KLBSNetSimServerBinary, KNullDesC); + + if (err == KErrNone) + { + TRequestStatus status; + + // Start the server + server.Rendezvous(status); + if (status != KRequestPending) + { + server.Kill(KErrNone); + } // if + else + { + server.Resume(); + } // else + + // Wait for server to start + User::WaitForRequest(status); + + // Result + err = (server.ExitType() == EExitPanic) ? KErrGeneral : status.Int(); + + // Cleanup + server.Close(); + } // if + + return err; + } + +// +// CNotifications: CNotificationConnect +RLbsNetSimTest::CNotificationConnect::CNotificationConnect(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver) + { + CActiveScheduler::Add(this); + + TIpcArgs args(ENotificationConnect); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationConnect::~CNotificationConnect() + { + Cancel(); + } + +void RLbsNetSimTest::CNotificationConnect::RunL() + { + if (iStatus == KErrNone) + { + iObserver->Connected(); + + TIpcArgs args(ENotificationConnect); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } // if + } + +void RLbsNetSimTest::CNotificationConnect::DoCancel() + { + TIpcArgs args(ENotificationConnectCancel); + iTest->Send(ECallbacks, args); + } + + +// +// CNotifications: CNotificationDisconnect +RLbsNetSimTest::CNotificationDisconnect::CNotificationDisconnect(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver) + { + CActiveScheduler::Add(this); + + TIpcArgs args(ENotificationDisconnect); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationDisconnect::~CNotificationDisconnect() + { + Cancel(); + } + + +void RLbsNetSimTest::CNotificationDisconnect::RunL() + { + if (iStatus == KErrNone) + { + iObserver->Disconnected(); + + TIpcArgs args(ENotificationDisconnect); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } // if + } + +void RLbsNetSimTest::CNotificationDisconnect::DoCancel() + { + TIpcArgs args(ENotificationDisconnectCancel); + iTest->Send(ECallbacks, args); + } + + +// +// CNotifications: CNotificationRegisterLcsMoLr +RLbsNetSimTest::CNotificationRegisterLcsMoLr::CNotificationRegisterLcsMoLr(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver) + { + CActiveScheduler::Add(this); + + TIpcArgs args(ENotificationRegisterLcsMoLr, &iData); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationRegisterLcsMoLr::~CNotificationRegisterLcsMoLr() + { + Cancel(); + } + + +void RLbsNetSimTest::CNotificationRegisterLcsMoLr::RunL() + { + if (iStatus == KErrNone) + { + iObserver->NotifyRegisterLcsMoLr(iData); + + TIpcArgs args(ENotificationRegisterLcsMoLr, &iData); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } // if + } + +void RLbsNetSimTest::CNotificationRegisterLcsMoLr::DoCancel() + { + TIpcArgs args(ENotificationRegisterLcsMoLrCancel); + iTest->Send(ECallbacks, args); + } + + +// +// CNotifications: CNotificationReleaseLcsMoLr +// +// Priority of this object is low as it should be the last notification fired if more than +// one notification is active at the same time +RLbsNetSimTest::CNotificationReleaseLcsMoLr::CNotificationReleaseLcsMoLr(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityMuchLess), iTest(aTest), iObserver(aObserver), iReasonPkg(iReason) + { + CActiveScheduler::Add(this); + + TIpcArgs args(ENotificationReleaseLcsMoLr, &iReasonPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationReleaseLcsMoLr::~CNotificationReleaseLcsMoLr() + { + Cancel(); + } + + +void RLbsNetSimTest::CNotificationReleaseLcsMoLr::RunL() + { + if (iStatus == KErrNone) + { + iObserver->NotifyReleaseLcsMoLr(iReason); + + TIpcArgs args(ENotificationReleaseLcsMoLr, &iReasonPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } // if + } + +void RLbsNetSimTest::CNotificationReleaseLcsMoLr::DoCancel() + { + TIpcArgs args(ENotificationReleaseLcsMoLrCancel); + iTest->Send(ECallbacks, args); + } +// +// CNotifications: CNotificationMeasurementReport +RLbsNetSimTest::CNotificationMeasurementReport::CNotificationMeasurementReport(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver), iPositionPkg(iPosition) + { + CActiveScheduler::Add(this); + + TIpcArgs args(ENotificationMeasurementReport, &iPositionPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationMeasurementReport::~CNotificationMeasurementReport() + { + Cancel(); + } + + +void RLbsNetSimTest::CNotificationMeasurementReport::RunL() + { + if (iStatus == KErrNone) + { + iObserver->NotifyMeasurementReportLocation(iPosition); + + TIpcArgs args(ENotificationMeasurementReport, &iPositionPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } // if + } + +void RLbsNetSimTest::CNotificationMeasurementReport::DoCancel() + { + TIpcArgs args(ENotificationMeasurementReportCancel); + iTest->Send(ECallbacks, args); + } + +// +// CNotifications: CNotificationMeasurementReportRequestMoreAssitanceData +RLbsNetSimTest::CNotificationMeasurementReportRequestMoreAssitanceData::CNotificationMeasurementReportRequestMoreAssitanceData(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver), iFilterPkg(iFilter) + { + CActiveScheduler::Add(this); + + TIpcArgs args(ENotificationMeasurementReportRequestMoreAssitanceData, &iFilterPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationMeasurementReportRequestMoreAssitanceData::~CNotificationMeasurementReportRequestMoreAssitanceData() + { + Cancel(); + } + + +void RLbsNetSimTest::CNotificationMeasurementReportRequestMoreAssitanceData::RunL() + { + if (iStatus == KErrNone) + { + iObserver->NotifyMeasurementReportRequestMoreAssistanceData(iFilter); + + TIpcArgs args(ENotificationMeasurementReportRequestMoreAssitanceData, &iFilterPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } // if + } + +void RLbsNetSimTest::CNotificationMeasurementReportRequestMoreAssitanceData::DoCancel() + { + TIpcArgs args(ENotificationMeasurementReportRequestMoreAssitanceDataCancel); + iTest->Send(ECallbacks, args); + } + +// +// CNotifications: CNotificationMeasurementReportControlFailure +RLbsNetSimTest::CNotificationMeasurementReportControlFailure::CNotificationMeasurementReportControlFailure(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver), iReasonPkg(iReason) + { + CActiveScheduler::Add(this); + + TIpcArgs args(ENotificationMeasurementReportControlFailure, &iReasonPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationMeasurementReportControlFailure::~CNotificationMeasurementReportControlFailure() + { + Cancel(); + } + + +void RLbsNetSimTest::CNotificationMeasurementReportControlFailure::RunL() + { + if (iStatus == KErrNone) + { + iObserver->NotifyMeasurementReportControlFailure(iReason); + + TIpcArgs args(ENotificationMeasurementReportControlFailure, &iReasonPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } // if + } + +void RLbsNetSimTest::CNotificationMeasurementReportControlFailure::DoCancel() + { + TIpcArgs args(ENotificationMeasurementReportControlFailureCancel); + iTest->Send(ECallbacks, args); + } + +// +// CNotifications: CNotificationMeasurementControlLocation +RLbsNetSimTest::CNotificationMeasurementControlLocation* RLbsNetSimTest::CNotificationMeasurementControlLocation::NewL(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) + { + CNotificationMeasurementControlLocation* self = new (ELeave) CNotificationMeasurementControlLocation(aTest, aObserver); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + + return self; + } + +void RLbsNetSimTest::CNotificationMeasurementControlLocation::ConstructL() + { + iAssistanceData = HBufC8::NewL(RLbsAssistanceDataBuilderSet::MaxExternalizedBufferSize()); + iPtr.Set(iAssistanceData->Des()); + + TIpcArgs args(ENotificationMeasurementControlLocation, &iPositionPkg, &iQualityPkg, &iPtr); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationMeasurementControlLocation::CNotificationMeasurementControlLocation(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver), + iPositionPkg(iPosition), iQualityPkg(iQuality), iPtr(NULL, 0) + { + CActiveScheduler::Add(this); + } + +RLbsNetSimTest::CNotificationMeasurementControlLocation::~CNotificationMeasurementControlLocation() + { + Cancel(); + delete iAssistanceData; + } + + +void RLbsNetSimTest::CNotificationMeasurementControlLocation::RunL() + { + if (iStatus == KErrNone) + { + // Read the assistance data back out + RLbsAssistanceDataBuilderSet assistanceData; + CleanupClosePushL(assistanceData); + assistanceData.OpenL(); + RDesReadStream stream(iPtr); + CleanupClosePushL(stream); + assistanceData.InternalizeL(stream); + + iObserver->NotifyMeasurementControlLocation(iPosition, assistanceData, iQuality); + + + TIpcArgs args(ENotificationMeasurementControlLocation, &iPositionPkg, &iQualityPkg, &iPtr); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + + // Cleanup + CleanupStack::PopAndDestroy(2); + } // if + } + +void RLbsNetSimTest::CNotificationMeasurementControlLocation::DoCancel() + { + TIpcArgs args(ENotificationMeasurementControlLocationCancel); + iTest->Send(ECallbacks, args); + } + +// +// CNotifications: CNotificationFacilityLcsMoLrResult +RLbsNetSimTest::CNotificationFacilityLcsMoLrResult::CNotificationFacilityLcsMoLrResult(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver), iReasonPkg(iReason), iPositionPkg(iPosition) + { + CActiveScheduler::Add(this); + + TIpcArgs args(ENotificationFacilityLcsMoLrResult, &iReasonPkg, &iPositionPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } + +RLbsNetSimTest::CNotificationFacilityLcsMoLrResult::~CNotificationFacilityLcsMoLrResult() + { + Cancel(); + } + + +void RLbsNetSimTest::CNotificationFacilityLcsMoLrResult::RunL() + { + if (iStatus == KErrNone) + { + iObserver->NotifyFacilityLcsMoLrResult(iReason, iPosition); + + TIpcArgs args(ENotificationFacilityLcsMoLrResult, &iReasonPkg, &iPositionPkg); + iTest->SendReceive(ECallbacks, args, iStatus); + SetActive(); + } // if + } + +void RLbsNetSimTest::CNotificationFacilityLcsMoLrResult::DoCancel() + { + TIpcArgs args(ENotificationFacilityLcsMoLrResultCancel); + iTest->Send(ECallbacks, args); + } +// +// CNotifications: CMessageReleaseLcsLocationNotification +RLbsNetSimTest::CMessageReleaseLcsLocationNotification::CMessageReleaseLcsLocationNotification(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver), iTypePkg(iType), + iRequestInfoPkg(iRequestInfo), iResponsePkg(iResponse) + { + CActiveScheduler::Add(this); + } + +RLbsNetSimTest::CMessageReleaseLcsLocationNotification::~CMessageReleaseLcsLocationNotification() + { + Cancel(); + } + +void RLbsNetSimTest::CMessageReleaseLcsLocationNotification::Send(TLbsNetPosRequestPrivacy& aType, TLbsExternalRequestInfo& aRequestInfo) + { + iType = aType; + iRequestInfo = aRequestInfo; + TIpcArgs args(&iTypePkg, &iRequestInfoPkg, &iResponsePkg); + iTest->SendReceive(ETReleaseLcsLocationNotification, args, iStatus); + SetActive(); + } + +void RLbsNetSimTest::CMessageReleaseLcsLocationNotification::RunL() + { + if (iStatus == KErrNone) + { + iObserver->NotifyReleaseLcsLocationNotification(iResponse); + } // if + else + { + iObserver->NotifyError(MLbsNetSimTestObserver::EStartNetworkPrivacyRequest, iStatus.Int()); + } + } + +void RLbsNetSimTest::CMessageReleaseLcsLocationNotification::DoCancel() + { + iTest->Send(ETReleaseLcsLocationNotificationCancel); + } +// +// CNotifications: CMessageReleaseLcsLocationNotification +RLbsNetSimTest::CMessageStartNetworkLocationRequest::CMessageStartNetworkLocationRequest(RLbsNetSimTest* aTest, MLbsNetSimTestObserver* aObserver) : + CActive(EPriorityStandard), iTest(aTest), iObserver(aObserver) + { + CActiveScheduler::Add(this); + } + +RLbsNetSimTest::CMessageStartNetworkLocationRequest::~CMessageStartNetworkLocationRequest() + { + Cancel(); + } + +void RLbsNetSimTest::CMessageStartNetworkLocationRequest::Send() + { + iTest->SendReceive(ETStartNetworkLocationRequest, iStatus); + SetActive(); + } + +void RLbsNetSimTest::CMessageStartNetworkLocationRequest::RunL() + { + if (iStatus != KErrNone) + { + iObserver->NotifyError(MLbsNetSimTestObserver::EStartNetworkLocationRequest, iStatus.Int()); + } // if + } + +void RLbsNetSimTest::CMessageStartNetworkLocationRequest::DoCancel() + { + iTest->Send(ETStartNetworkLocationRequestCancel); + }