diff -r 000000000000 -r 9cfd9a3ee49c networkprotocolmodules/networkprotocolmodule/LbsNetSim/src/lbsnetsimtesthandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkprotocolmodules/networkprotocolmodule/LbsNetSim/src/lbsnetsimtesthandler.cpp Tue Feb 02 01:50:39 2010 +0200 @@ -0,0 +1,840 @@ +// 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 "lbsnetsimtesthandler.h" +#include "lbsnetsimassistancedataprovider.h" +#include "lbsnetsimgatewayhandler.h" +#include +#include +#include + +#include +#include + +/** +*/ +CLbsNetSimTestHandler* CLbsNetSimTestHandler::NewL(CLbsNetSimAssistanceDataProvider& aAssistanceDataProvider) + { + CLbsNetSimTestHandler* self = new(ELeave) CLbsNetSimTestHandler(aAssistanceDataProvider); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + + return self; + } + + +/** +*/ +void CLbsNetSimTestHandler::SetGatewayHandler(CLbsNetSimGatewayHandler* aGatewayHandler) + { + iGatewayHandler = aGatewayHandler; + } + + +/** +*/ +void CLbsNetSimTestHandler::ServiceL(const RMessage2& aMessage) + { + switch (aMessage.Function()) + { + case ECallbacks: + { + HandleCallbacksL(aMessage); + break; + } + case ETSetReferenceLocation: + { + HandleSetReferenceLocationL(aMessage); + break; + } + case ETSetReferenceLocationData: + { + HandleSetReferenceLocationDataL(aMessage); + break; + } + case ETSetResponseTime: + { + HandleSetResponseTime(aMessage); + break; + } + case ETSetResponseError: + { + HandleSetResponseError(aMessage); + break; + } + case ETSetDefaultAssitanceDataFilter: + { + HandleSetDefaultAssitanceDataFilter(aMessage); + break; + } + case ETSetMoreDefaultAssitanceDataFilter: + { + HandleSetMoreDefaultAssitanceDataFilter(aMessage); + break; + } + case ETClearAssitanceDataFilters: + { + HandleClearAssitanceDataFilters(aMessage); + break; + } + case ETSetAssistanceDataProvider: + { + HandleSetAssistanceDataProvider(aMessage); + break; + } + case ETSetEmergenyStatus: + { + HandleSetEmergenyStatus(aMessage); + break; + } + case ETSetRoamingStatus: + { + HandleSetRoamingStatus(aMessage); + break; + } + case ETSetRequestQuality: + { + HandleSetQuality(aMessage); + break; + } + case ETSetStepMode: + { + HandleSetStepMode(aMessage); + break; + } + case ETReleaseLcsLocationNotification: + { + HandleReleaseLcsLocationNotificationL(aMessage); + break; + } + case ETReleaseLcsLocationNotificationCancel: + { + if (!iMessageReleaseLcsLocationNotification.IsNull()) + { + iMessageReleaseLcsLocationNotification.Complete(KErrCancel); + } + break; + } + case ETStartNetworkLocationRequest: + { + HandleStartNetworkLocationRequestL(aMessage); + break; + } + case ETStartNetworkLocationRequestCancel: + { + if (!iMessageStartNetworkLocationRequest.IsNull()) + { + iMessageStartNetworkLocationRequest.Complete(KErrCancel); + } + break; + } + case ETSendResetAssistanceData: + { + HandleSendResetAssistanceData(aMessage); + break; + } + default: + { + User::Leave(KErrNotSupported); + } + } + } + + +/** +*/ +void CLbsNetSimTestHandler::Connected() + { + iFireConnectedNotification = ETrue; + + // Attach to step mode property + iStepModeProperty.Attach(TUid::Uid(KLbsNetSimClient), KLbsStepModeKey); + } + + +/** +*/ +void CLbsNetSimTestHandler::Disconnected() + { + // Clean up some values + RProperty::Set(TUid::Uid(KLbsNetSimStatus), KLbsRoamingStatus, EFalse); + RProperty::Set(TUid::Uid(KLbsNetSimStatus), KLbsEmergencyStatus, EFalse); + + // Detach from step mode property + iStepModeProperty.Close(); + + // Complete any outstanding RMessage2's + if (!iMessageConnect.IsNull()) + { + iMessageConnect.Complete(KErrDisconnected); + } + + if (!iMessageDisconnect.IsNull()) + { + iMessageDisconnect.Complete(KErrDisconnected); + } + + if (!iMessageRegisterLcsMoLr.IsNull()) + { + iMessageRegisterLcsMoLr.Complete(KErrDisconnected); + } + + if (!iMessageMeasurementControlLocation.IsNull()) + { + iMessageMeasurementControlLocation.Complete(KErrDisconnected); + } + + if (!iMessageReleaseLcsMoLr.IsNull()) + { + iMessageReleaseLcsMoLr.Complete(KErrDisconnected); + } + + if (!iMessageReleaseLcsLocationNotification.IsNull()) + { + iMessageReleaseLcsLocationNotification.Complete(KErrDisconnected); + } + + if (!iMessageMeasurementReportLocation.IsNull()) + { + iMessageMeasurementReportLocation.Complete(KErrDisconnected); + } + + if (!iMessageMeasurementReportRequestMoreAssitanceData.IsNull()) + { + iMessageMeasurementReportRequestMoreAssitanceData.Complete(KErrDisconnected); + } + + if (!iMessageMeasurementReportControlFailure.IsNull()) + { + iMessageMeasurementReportControlFailure.Complete(KErrDisconnected); + } + + if (!iMessageFacilityLcsMoLrResult.IsNull()) + { + iMessageFacilityLcsMoLrResult.Complete(KErrDisconnected); + } + + if (!iMessageStartNetworkLocationRequest.IsNull()) + { + iMessageStartNetworkLocationRequest.Complete(KErrDisconnected); + } + } + + +/** +*/ +TInt CLbsNetSimTestHandler::GatewayConnected() + { + if (!iMessageConnect.IsNull()) + { + iMessageConnect.Complete(KErrNone); + iFireConnectedNotification = EFalse; + } + else + { + iFireConnectedNotification = ETrue; + } + + iGatewayConnected = ETrue; + + return KErrNone; + } + + +/** +*/ +TInt CLbsNetSimTestHandler::GatewayDisconnected() + { + if (!iMessageDisconnect.IsNull()) + { + iMessageDisconnect.Complete(KErrNone); + } + + iGatewayConnected = EFalse; + + return KErrNone; + } + + +/** +*/ +TInt CLbsNetSimTestHandler::GatewayRegisterLcsMoLr(const TDesC& aData) + { + TInt ret = KErrNone; + + if (!iMessageRegisterLcsMoLr.IsNull()) + { + iMessageRegisterLcsMoLr.Write(1, aData, 0); + iMessageRegisterLcsMoLr.Complete(KErrNone); + + ret = StepModeWait(); + } + + return ret; + } + +TInt CLbsNetSimTestHandler::GatewayProcessAssistanceDataL(RLbsAssistanceDataBuilderSet& aAssistanceData, + TPositionInfo& aPosition, + TLbsNetPosRequestQuality& aQuality) + { + TInt ret = KErrNone; + + if (!iMessageMeasurementControlLocation.IsNull()) + { + // Write position to message + TPckg positionPkg(aPosition); + iMessageMeasurementControlLocation.WriteL(1, positionPkg, 0); + + // Write quality to message + TPckg qualityPkg(aQuality); + iMessageMeasurementControlLocation.WriteL(2, qualityPkg, 0); + + // Write assistance data to the message + HBufC8* buffer = HBufC8::NewLC(RLbsAssistanceDataBuilderSet::MaxExternalizedBufferSize()); + TPtr8 des(buffer->Des()); + RDesWriteStream stream(des); + CleanupClosePushL(stream); + aAssistanceData.ExternalizeL(stream); + stream.CommitL(); + iMessageMeasurementControlLocation.WriteL(3, des, 0); + CleanupStack::PopAndDestroy(2, buffer); + + iMessageMeasurementControlLocation.Complete(KErrNone); + + ret = StepModeWait(); + } // if + + return ret; + } + +/** +*/ +TInt CLbsNetSimTestHandler::GatewayMeasurementReportLocationL(const TPositionInfo& aPosition) + { + TInt ret = KErrNone; + + if (!iMessageMeasurementReportLocation.IsNull()) + { + // Write args + TPckg positionPkg(aPosition); + iMessageMeasurementReportLocation.WriteL(1, positionPkg, 0); + + iMessageMeasurementReportLocation.Complete(KErrNone); + + ret = StepModeWait(); + } // if + + return ret; + } + + +/** +*/ +TInt CLbsNetSimTestHandler::GatewayFacilityLcsMoLrResultL(const TInt aReason, const TPositionInfo& aPosition) + { + TInt ret = KErrNone; + + if (!iMessageFacilityLcsMoLrResult.IsNull()) + { + // Write args + TPckg reasonPkg(aReason); + TPckg positionPkg(aPosition); + iMessageFacilityLcsMoLrResult.WriteL(1, reasonPkg, 0); + iMessageFacilityLcsMoLrResult.WriteL(2, positionPkg, 0); + + iMessageFacilityLcsMoLrResult.Complete(KErrNone); + + ret = StepModeWait(); + } + + return ret; + } + + +TInt CLbsNetSimTestHandler::GatewayReleaseLcsMoLrL(const TInt aReason) + { + TInt ret = KErrNone; + + if (!iMessageReleaseLcsMoLr.IsNull()) + { + // Write args + TPckg reasonPkg(aReason); + iMessageReleaseLcsMoLr.WriteL(1, reasonPkg, 0); + + iMessageReleaseLcsMoLr.Complete(KErrNone); + + ret = StepModeWait(); + } + + return ret; + } + + +/** +*/ +TInt CLbsNetSimTestHandler::GatewayMeasurementControlFailureL(const TInt aReason) + { + TInt ret = KErrNone; + + if (!iMessageMeasurementReportControlFailure.IsNull()) + { + // Write args + TPckg reasonPkg(aReason); + iMessageMeasurementReportControlFailure.WriteL(1, reasonPkg, 0); + + iMessageMeasurementReportControlFailure.Complete(KErrNone); + + ret = StepModeWait(); + } + + return ret; + } + + +/** +*/ +TInt CLbsNetSimTestHandler::GatewayRequestMoreAssistanceDataL(const TLbsAssistanceDataGroup& aFilter) + { + TInt ret = KErrNone; + + if (!iMessageMeasurementReportRequestMoreAssitanceData.IsNull()) + { + // Write args + TPckg filterPkg(aFilter); + iMessageMeasurementReportRequestMoreAssitanceData.WriteL(1, filterPkg, 0); + + iMessageMeasurementReportRequestMoreAssitanceData.Complete(KErrNone); + + ret = StepModeWait(); + } + + return ret; + } + + + +/** +*/ +TInt CLbsNetSimTestHandler::GatewayReleaseLcsLocationNotificationL(const CLbsNetworkProtocolBase::TLbsPrivacyResponse& aResponse) + { + TInt ret = KErrNone; + + if (!iMessageReleaseLcsLocationNotification.IsNull()) + { + TPckg responsePkg(aResponse); + iMessageReleaseLcsLocationNotification.WriteL(2, responsePkg, 0); + + iMessageReleaseLcsLocationNotification.Complete(KErrNone); + + ret = StepModeWait(); + } + + return ret; + } + + +// +// Private + + +/** +*/ +CLbsNetSimTestHandler::CLbsNetSimTestHandler(CLbsNetSimAssistanceDataProvider& aAssitanceDataProvider) : + iAssistanceDataProvider(aAssitanceDataProvider), iGatewayConnected(EFalse), + iFireConnectedNotification(EFalse), iStepMode(EFalse) + { + } + + +/** +*/ +void CLbsNetSimTestHandler::ConstructL() + { + // Create publish & subscribe flags + TUid statusUid = TUid::Uid(KLbsNetSimStatus); + TInt err = RProperty::Define(KLbsEmergencyStatus, RProperty::EInt, ECapability_None, ECapabilityWriteDeviceData, EFalse); + if ((err != KErrNone) && (err != KErrAlreadyExists)) + { + User::Leave(err); + } + User::LeaveIfError(RProperty::Set(statusUid, KLbsEmergencyStatus, EFalse)); + + err = RProperty::Define(statusUid, KLbsRoamingStatus, RProperty::EInt, ECapability_None, ECapabilityWriteDeviceData); + if ((err != KErrNone) && (err != KErrAlreadyExists)) + { + User::Leave(err); + } + User::LeaveIfError(RProperty::Set(statusUid, KLbsRoamingStatus, EFalse)); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleCallbacksL(const RMessage2& aMessage) + { + switch (aMessage.Int0()) + { + case ENotificationConnect: + { + iMessageConnect = aMessage; + if (iGatewayConnected && iFireConnectedNotification) + { + iMessageConnect.Complete(KErrNone); + iFireConnectedNotification = EFalse; + } + break; + } + case ENotificationConnectCancel: + { + if (!iMessageConnect.IsNull()) + { + iMessageConnect.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + case ENotificationDisconnect: + { + iMessageDisconnect = aMessage; + break; + } + case ENotificationDisconnectCancel: + { + if (!iMessageDisconnect.IsNull()) + { + iMessageDisconnect.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + case ENotificationRegisterLcsMoLr: + { + iMessageRegisterLcsMoLr = aMessage; + break; + } + case ENotificationRegisterLcsMoLrCancel: + { + if (!iMessageRegisterLcsMoLr.IsNull()) + { + iMessageRegisterLcsMoLr.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + case ENotificationMeasurementControlLocation: + { + iMessageMeasurementControlLocation = aMessage; + break; + } + case ENotificationMeasurementControlLocationCancel: + { + if (!iMessageMeasurementControlLocation.IsNull()) + { + iMessageMeasurementControlLocation.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + case ENotificationReleaseLcsMoLr: + { + iMessageReleaseLcsMoLr = aMessage; + break; + } + case ENotificationReleaseLcsMoLrCancel: + { + if (!iMessageReleaseLcsMoLr.IsNull()) + { + iMessageReleaseLcsMoLr.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + case ENotificationMeasurementReport: + { + iMessageMeasurementReportLocation = aMessage; + break; + } + case ENotificationMeasurementReportCancel: + { + if (!iMessageMeasurementReportLocation.IsNull()) + { + iMessageMeasurementReportLocation.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + case ENotificationMeasurementReportRequestMoreAssitanceData: + { + iMessageMeasurementReportRequestMoreAssitanceData = aMessage; + break; + } + case ENotificationMeasurementReportRequestMoreAssitanceDataCancel: + { + if (!iMessageMeasurementReportRequestMoreAssitanceData.IsNull()) + { + iMessageMeasurementReportRequestMoreAssitanceData.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + case ENotificationMeasurementReportControlFailure: + { + iMessageMeasurementReportControlFailure = aMessage; + break; + } + case ENotificationMeasurementReportControlFailureCancel: + { + if (!iMessageMeasurementReportControlFailure.IsNull()) + { + iMessageMeasurementReportControlFailure.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + case ENotificationFacilityLcsMoLrResult: + { + iMessageFacilityLcsMoLrResult = aMessage; + break; + } + case ENotificationFacilityLcsMoLrResultCancel: + { + if (!iMessageFacilityLcsMoLrResult.IsNull()) + { + iMessageFacilityLcsMoLrResult.Complete(KErrCancel); + } + aMessage.Complete(KErrNone); + break; + } + + default: + { + User::Leave(KErrNotSupported); + } + } + } + +/** +*/ +void CLbsNetSimTestHandler::HandleSetReferenceLocationL(const RMessage2& aMessage) + { + TPosition position; + TPckg positionPkg(position); + aMessage.ReadL(0, positionPkg, 0); + + iAssistanceDataProvider.SetReferenceLocation(position); + + aMessage.Complete(KErrNone); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleSetReferenceLocationDataL(const RMessage2& aMessage) + { + HBufC8* buffer = HBufC8::NewLC(aMessage.GetDesLength(0)); + TPtr8 ptr(buffer->Des()); + aMessage.ReadL(0, ptr, 0); + + iAssistanceDataProvider.SetReferenceLocationL(ptr); + + CleanupStack::Pop(buffer); + + aMessage.Complete(KErrNone); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleSetResponseTime(const RMessage2& aMessage) + { + iGatewayHandler->SetResponseTime(aMessage.Int0(), aMessage.Int1()); + + aMessage.Complete(KErrNone); + } + +void CLbsNetSimTestHandler::HandleSetResponseError(const RMessage2& aMessage) + { + iGatewayHandler->SetResponseError(aMessage.Int0(), aMessage.Int1()); + + aMessage.Complete(KErrNone); + } + +/** +*/ +void CLbsNetSimTestHandler::HandleSetDefaultAssitanceDataFilter(const RMessage2& aMessage) + { + TLbsAssistanceDataGroup filter; + TPckg filterPkg(filter); + aMessage.Read(0, filterPkg, 0); + + iGatewayHandler->SetAssistanceDataMask(filter); + + aMessage.Complete(KErrNone); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleSetMoreDefaultAssitanceDataFilter(const RMessage2& aMessage) + { + TLbsAssistanceDataGroup filter; + TPckg filterPkg(filter); + aMessage.Read(0, filterPkg, 0); + + iGatewayHandler->SetMoreAssistanceDataMask(filter); + + aMessage.Complete(KErrNone); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleClearAssitanceDataFilters(const RMessage2& aMessage) + { + iGatewayHandler->ClearAssistanceDataMasks(); + + aMessage.Complete(KErrNone); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleSetAssistanceDataProvider(const RMessage2& aMessage) + { + TUid uid; + uid.iUid = aMessage.Int0(); + + iAssistanceDataProvider.SetAssistanceDataProvider(uid); + + aMessage.Complete(KErrNone); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleSetEmergenyStatus(const RMessage2& aMessage) + { + aMessage.Complete(RProperty::Set(TUid::Uid(KLbsNetSimStatus), KLbsEmergencyStatus, aMessage.Int0())); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleSetRoamingStatus(const RMessage2& aMessage) + { + aMessage.Complete(RProperty::Set(TUid::Uid(KLbsNetSimStatus), KLbsRoamingStatus, aMessage.Int0())); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleSetQuality(const RMessage2& aMessage) + { + TLbsNetPosRequestQuality quality; + TPckg qualityPkg(quality); + aMessage.Read(0, qualityPkg, 0); + + iAssistanceDataProvider.SetQuality(quality); + + aMessage.Complete(KErrNone); + } + +/** +*/ +void CLbsNetSimTestHandler::HandleSetStepMode(const RMessage2& aMessage) + { + iStepMode = aMessage.Int0(); + + aMessage.Complete(KErrNone); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleReleaseLcsLocationNotificationL(const RMessage2& aMessage) + { + iMessageReleaseLcsLocationNotification = aMessage; + + // Read arguments + TLbsNetPosRequestPrivacy type; + TPckg typePkg(type); + aMessage.ReadL(0, typePkg, 0); + + TLbsExternalRequestInfo requestInfo; + TPckg requestInfoPkg(requestInfo); + aMessage.ReadL(1, requestInfoPkg, 0); + + TRAPD(err, iGatewayHandler->StartNetworkPrivacyRequestL(type, requestInfo)); + if (err != KErrNone) + { + aMessage.Complete(err); + } + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleReleaseLcsLocationNotificationCancelL() + { + iGatewayHandler->CancelNetworkPrivacyRequestL(); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleStartNetworkLocationRequestL(const RMessage2& aMessage) + { + iMessageStartNetworkLocationRequest = aMessage; + + TRAPD(err, iGatewayHandler->StartNetworkLocationRequestL()); + iMessageStartNetworkLocationRequest.Complete(err); + } + + +/** +*/ +void CLbsNetSimTestHandler::HandleStartNetworkLocationRequestCancelL() + { + iGatewayHandler->CancelNetworkLocationRequestL(); + } + +void CLbsNetSimTestHandler::HandleSendResetAssistanceData(const RMessage2& aMessage) + { + iGatewayHandler->SendResetAssistanceData(aMessage.Int0()); + + aMessage.Complete(KErrNone); + } + + +/** +*/ +TInt CLbsNetSimTestHandler::StepModeWait() + { + TInt ret = KErrNone; + + if (iStepMode) + { + // Subscribe and wait for the step mode property + TRequestStatus status; + iStepModeProperty.Subscribe(status); + User::WaitForRequest(status); + + // Get the new property + iStepModeProperty.Get(ret); + } + + return ret; + }