diff -r a2efdd544abf -r b47902b73a93 locationmgmt/networkgateway/test/netprotocoltest/src/lbsnetgatewayprotocoltest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/locationmgmt/networkgateway/test/netprotocoltest/src/lbsnetgatewayprotocoltest.cpp Fri Jun 04 10:34:15 2010 +0100 @@ -0,0 +1,540 @@ +// 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: +// Source file for the 'stub' network protocol module used in +// the Network Gateway unit tests. +// +// + +/** + @file + @internalTechnology + @released +*/ + +#include +#include +#include +#include +#include "lbsdevloggermacros.h" +#include "lbsnetgatewayprotocoltest.h" + + +_LIT(KLbsTestNetworkProtocol,"LbsTestNetworkProtocol"); + + + +// +// ECom instantiation functions +// + +const TImplementationProxy KImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x10282250, CTestLbsNetworkProtocol::New0L), + IMPLEMENTATION_PROXY_ENTRY(0x10285AB9, CTestLbsNetworkProtocol::New1L), + // Entry points for multiple PM test + IMPLEMENTATION_PROXY_ENTRY(0x102871C8, CTestLbsNetworkProtocol::New2L), + IMPLEMENTATION_PROXY_ENTRY(0x102871C9, CTestLbsNetworkProtocol::New3L), + IMPLEMENTATION_PROXY_ENTRY(0x102871CA, CTestLbsNetworkProtocol::New4L), + IMPLEMENTATION_PROXY_ENTRY(0x102871CB, CTestLbsNetworkProtocol::New5L), + IMPLEMENTATION_PROXY_ENTRY(0x102871CC, CTestLbsNetworkProtocol::New6L), + IMPLEMENTATION_PROXY_ENTRY(0x102871CD, CTestLbsNetworkProtocol::New7L), + IMPLEMENTATION_PROXY_ENTRY(0x102871CE, CTestLbsNetworkProtocol::New8L), + IMPLEMENTATION_PROXY_ENTRY(0x102871CF, CTestLbsNetworkProtocol::New9L), + + // Another 10 entry points for the roaming PMs + IMPLEMENTATION_PROXY_ENTRY(0x102871D0, CTestLbsNetworkProtocol::New10L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D1, CTestLbsNetworkProtocol::New11L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D2, CTestLbsNetworkProtocol::New12L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D3, CTestLbsNetworkProtocol::New13L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D4, CTestLbsNetworkProtocol::New14L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D5, CTestLbsNetworkProtocol::New15L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D6, CTestLbsNetworkProtocol::New16L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D7, CTestLbsNetworkProtocol::New17L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D8, CTestLbsNetworkProtocol::New18L), + IMPLEMENTATION_PROXY_ENTRY(0x102871D9, CTestLbsNetworkProtocol::New19L), + }; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = (sizeof(KImplementationTable) / sizeof(TImplementationProxy)); + return KImplementationTable; + } + +// +// CTestLbsNetworkProtocol Implementation +// + +CTestLbsNetworkProtocol::CTestLbsNetworkProtocol(TUint aModuleIndex, + TLbsNetProtocolModuleParams& aParams) : iObserver(aParams.Observer()), + iTestChannel(aModuleIndex), + iModuleIndex(aModuleIndex) + { + LBSLOG(ELogP1, "CTestLbsNetworkProtocol::CTestLbsNetworkProtocol:"); + } + +CTestLbsNetworkProtocol::~CTestLbsNetworkProtocol() + { + LBSLOG(ELogP1, "CTestLbsNetworkProtocol::~CTestLbsNetworkProtocol:"); + iTestChannel.Close(); + RNetGatewayProtocolTestChannel::Shutdown(iModuleIndex); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New0L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New1L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex2, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New2L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex3, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New3L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex4, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New4L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex5, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New5L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex6, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New6L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex7, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New7L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex8, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New8L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex9, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New9L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex10, aData); + } + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New10L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex11, aData); + } + +// 10 entry points for roaming modules +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New11L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex12, aData); + } +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New12L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex13, aData); + } +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New13L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex14, aData); + } +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New14L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex15, aData); + } +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New15L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex16, aData); + } +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New16L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex17, aData); + } +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New17L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex18, aData); + } +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New18L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex19, aData); + } +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::New19L(TAny* aData) + { + return NewL(KTe_LbsNetGatewayTestProtocolIndex20, aData); + } + + + +CTestLbsNetworkProtocol* CTestLbsNetworkProtocol::NewL(TUint aModuleIndex, TAny* aData) + { + LBSLOG(ELogP1, "CTestLbsNetworkProtocol::NewL:"); + TLbsNetProtocolModuleParams* params = reinterpret_cast(aData); + CTestLbsNetworkProtocol* self = new (ELeave) CTestLbsNetworkProtocol(aModuleIndex, *params); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +void CTestLbsNetworkProtocol::ConstructL() + { + LBSLOG(ELogP1, "CTestLbsNetworkProtocol::ConstructL:"); + RNetGatewayProtocolTestChannel::InitialiseL(iModuleIndex); + iTestChannel.OpenL(KTestAppChannelKey, KNetProtocolChannelKey, *this); + } + +void CTestLbsNetworkProtocol::RespondPrivacyRequest(const TLbsNetSessionId& aSessionId, + const TLbsPrivacyResponse& aResponse, + TInt /* aReason */) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RespondPrivacyRequest:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + LBSLOG2(ELogP2, "Response : %d", aResponse); + + TNetGatewayMsg msg; + SNetMsgRespondPrivacyRequest* response; + response = reinterpret_cast(msg.Data()); + msg.iType = ENetMsgRespondPrivacyRequest; + response->iSessionId = aSessionId; + response->iResponse = aResponse; + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + +void CTestLbsNetworkProtocol::RespondLocationRequest(const TLbsNetSessionId& aSessionId, + TInt aReason, + const TPositionInfoBase& aPosInfo) + { + const TPositionInfo& posInfo = static_cast(aPosInfo); + TPosition position; + posInfo.GetPosition(position); + + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RespondLocationRequest:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + LBSLOG2(ELogP2, "Reason : %d", aReason); + LBSLOG3(ELogP2, "Position : %LF lat, %LF long", position.Latitude(), + position.Longitude()); + + SNetMsgRespondLocationRequest* response; + TNetGatewayMsg msg; + response = reinterpret_cast(msg.Data()); + new (response) SNetMsgRespondLocationRequest; + msg.iType = ENetMsgRespondLocationRequest; + response->iSessionId = aSessionId; + response->iReason = aReason; + // This assumes that aPosInfo is really a reference to + // a TPositionSatelliteInfo. If this isn't true then + // the last part will be junk. + Mem::Copy(&response->iPositionInfo, &aPosInfo, response->iPositionInfo.PositionClassSize()); + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + + } + +void CTestLbsNetworkProtocol::RequestAssistanceData(TLbsAssistanceDataGroup aDataRequestMask, const TLbsNetSessionIdArray& /*aSessionIdArray*/) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RequestAssistanceData:"); + LBSLOG2(ELogP2, "Data Mask : 0x%x", aDataRequestMask); + + TNetGatewayMsg msg; + SNetMsgRequestAssistanceData* request; + request = reinterpret_cast(msg.Data()); + msg.iType = ENetMsgRequestAssistanceData; + request->iDataRequestMask = aDataRequestMask; + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + +void CTestLbsNetworkProtocol::RequestSelfLocation(const TLbsNetSessionId& aSessionId, + const TLbsNetPosRequestOptionsBase& aOptions) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RequestNetworkBasedLocation:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + + TNetGatewayMsg msg; + SNetMsgRequestSelfLocation* request; + request = reinterpret_cast(msg.Data()); + msg.iType = ENetMsgRequestSelfLocation; + const TLbsNetPosRequestOptionsAssistance assistOptions = reinterpret_cast(aOptions); + request->iSessionId = aSessionId; + request->iNewClient = assistOptions.NewClientConnected(); + request->iDataRequestMask = assistOptions.DataRequestMask(); + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + +void CTestLbsNetworkProtocol::CancelSelfLocation(const TLbsNetSessionId& aSessionId, + TInt aReason) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::CancelSelfLocation:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + LBSLOG2(ELogP2, "Reason : %d", aReason); + + TNetGatewayMsg msg; + SNetMsgCancelSelfLocation* cancel; + cancel = reinterpret_cast(msg.Data()); + msg.iType = ENetMsgCancelSelfLocation; + cancel->iSessionId = aSessionId; + cancel->iReason = aReason; + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + +void CTestLbsNetworkProtocol::RequestNetworkLocation(const TLbsNetSessionId& aSessionId, + const TLbsNetPosRequestOptionsBase& aOptions) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RequestNetworkLocation:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + + TNetGatewayMsg msg; + SNetMsgRequestNetworkLocation* request; + request = reinterpret_cast(msg.Data()); + msg.iType = ENetMsgRequestNetworkLocation; + const TLbsNetPosRequestOptions netOptions = reinterpret_cast(aOptions); + netOptions.GetRequestQuality(request->iQuality); + request->iSessionId = aSessionId; + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + +void CTestLbsNetworkProtocol::CancelNetworkLocation(const TLbsNetSessionId& aSessionId, + TInt aReason) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::CancelNetworkLocation:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + LBSLOG2(ELogP2, "Reason : %d", aReason); + + TNetGatewayMsg msg; + SNetMsgCancelNetworkLocation* cancel; + cancel = reinterpret_cast(msg.Data()); + msg.iType = ENetMsgCancelNetworkLocation; + cancel->iSessionId = aSessionId; + cancel->iReason = aReason; + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + +void CTestLbsNetworkProtocol::RequestTransmitLocation(const TLbsNetSessionId& aSessionId, + const TDesC& aDestination, + TInt aPriority, + const TLbsNetPosRequestOptionsBase& aOptions) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::RequestTransmitLocation:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + LBSLOG2(ELogP2, "Destination : %S", &aDestination); + LBSLOG2(ELogP2, "Priority : %d", aPriority); + + TNetGatewayMsg msg; + SNetMsgRequestTransmitLocation* request; + request = reinterpret_cast(msg.Data()); + new (request) SNetMsgRequestTransmitLocation; // in-place construction is needed to construct the descriptors (iDestination) + msg.iType = ENetMsgRequestTransmitLocation; + request->iSessionId = aSessionId; + request->iPriority = aPriority; + request->iDestination = aDestination; + request->iOptions = reinterpret_cast(aOptions); + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + +void CTestLbsNetworkProtocol::CancelTransmitLocation(const TLbsNetSessionId& aSessionId, + TInt aReason) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::CancelTransmitLocation:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + LBSLOG2(ELogP2, "Reason : %d", aReason); + + TNetGatewayMsg msg; + SNetMsgCancelTransmitLocation* cancel; + cancel = reinterpret_cast(msg.Data()); + msg.iType = ENetMsgCancelTransmitLocation; + cancel->iSessionId = aSessionId; + cancel->iReason = aReason; + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + +void CTestLbsNetworkProtocol::CancelExternalLocation( + const TLbsNetSessionId& aSessionId, + TInt aReason) + { + LBSLOG(ELogP2, "CTestLbsNetworkProtocol::CancelExternalLocation:"); + LBSLOG3(ELogP2, "SessionId : (%d, %d)\n", aSessionId.SessionOwner().iUid, + aSessionId.SessionNum()); + LBSLOG2(ELogP2, "Reason : %d", aReason); + + TNetGatewayMsg msg; + SNetMsgCancelExternalLocation* cancel; + cancel = reinterpret_cast(msg.Data()); + msg.iType = ENetMsgCancelExternalLocation; + cancel->iSessionId = aSessionId; + cancel->iReason = aReason; + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + } + + +void CTestLbsNetworkProtocol::AdviceSystemStatus(TLbsSystemStatus /*aStatus*/) + { +#pragma message("NOTE: CTestLbsNetworkProtocol::AdviceSystemStatus method not yet implemented. TBD") + } + +void CTestLbsNetworkProtocol::ProcessNetProtocolMessage(const TNetGatewayMsg& aMessage) + { + LBSLOG(ELogP1, "CTestLbsNetworkProtocol::ProcessNetProtocolMessage:"); + + switch (aMessage.iType) + { + case ENetMsgProcessPrivacyRequest: + { + const SNetMsgProcessPrivacyRequest* request; + request = reinterpret_cast(aMessage.Data()); + iObserver.ProcessPrivacyRequest(request->iSessionId, + request->iEmergency, + request->iPrivacy, + request->iRequestInfo); + break; + } + case ENetMsgProcessLocationRequest: + { + const SNetMsgProcessLocationRequest* request; + request = reinterpret_cast(aMessage.Data()); + iObserver.ProcessLocationRequest(request->iSessionId, + request->iEmergency, + request->iService, + request->iQuality, + request->iMethod); + break; + } + case ENetMsgProcessSessionComplete: + { + const SNetMsgProcessSessionComplete* complete; + complete = reinterpret_cast(aMessage.Data()); + iObserver.ProcessSessionComplete(complete->iSessionId, + complete->iReason); + break; + } + case ENetMsgProcessAssistanceData: + { + const SNetMsgProcessAssistanceData* data; + data = reinterpret_cast(aMessage.Data()); + iObserver.ProcessAssistanceData(data->iDataMask, + data->iData, + data->iReason); + break; + } + case ENetMsgProcessLocationUpdate: + { + const SNetMsgProcessLocationUpdate* location; + location = reinterpret_cast(aMessage.Data()); + iObserver.ProcessLocationUpdate(location->iSessionId, location->iReferenceLocation); + break; + } + case ENetMsgGetCurrentCapabilitiesRequest: + { + TNetGatewayMsg msg; + msg.iType = ENetMsgGetCurrentCapabilitiesResponse; + SNetMsgGetCurrentCapabilitiesResponse* response; + response = reinterpret_cast(msg.Data()); + iObserver.GetCurrentCapabilities(response->iCapabilities); + + TInt err = KErrNone; + TRAP(err, iTestChannel.SendNetProtocolMessageL(msg);) + if(err) + User::Panic(KLbsTestNetworkProtocol, err); + break; + } + case ENetMsgProcessStatusUpdate: + { + const SNetMsgProcessStatusUpdate* status; + status = reinterpret_cast(aMessage.Data()); + iObserver.ProcessStatusUpdate(status->iActiveServiceMask); + break; + } + case ENetMsgRespondPrivacyRequest: + case ENetMsgRespondLocationRequest: + case ENetMsgRequestTransmitLocation: + case ENetMsgCancelTransmitLocation: + case ENetMsgCancelExternalLocation: + case ENetMsgRequestAssistanceData: + case ENetMsgRequestSelfLocation: + case ENetMsgCancelSelfLocation: + case ENetMsgRequestNetworkLocation: + case ENetMsgCancelNetworkLocation: + case ENetMsgGetCurrentCapabilitiesResponse: + { + // The message go from the the plugin to the test code, + // so they should never be received here. + break; + } + case ENetMsgShutdownNetGateway: + { + CActiveScheduler::Stop(); + break; + } + default: + { + LBSLOG_ERR2(ELogP3, "Unhandled message type ; %d\n", aMessage.iType); + break; + } + } + } + +