// ---------------------------------------------------------
// CT_LbsTestTimerPsy::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsTestTimerPsy::NotifyPositionUpdate(
TPositionInfoBase& aPosInfo,
TRequestStatus& aStatus)
{
TPositionInfo* position = NULL;
position = static_cast<TPositionInfo*> (&aPosInfo);
iStatus = &aStatus;
*iStatus = KRequestPending;
TUid implUid = { KPosImplementationUid };
position->SetModuleId(implUid);
if (iTrackingEnabled)
{
// Set this position when tracking is enabled (on-going)
TCoordinate coor(55.0, 55.0, 55.0);
TLocality loc (coor, 1.0, 1.0);
TPosition pos (loc, TTime(0));
position -> SetPosition(pos);
}
else
{
// Set a dummy position
TCoordinate coor(20.0, 20.0, 20.0);
TLocality loc (coor, 1.0, 1.0);
TPosition pos (loc, TTime(0));
position -> SetPosition(pos);
User::RequestComplete(iStatus, KErrNone);
}
}
/**
GetLastPosition
@param aPos container for the position being returned (with KErrNone return)
@param aOldestValidTime the oldest valid time for a position being returned. If there is a valid position no older than this time, it should be returned.
@param aAllowPartial whether partial updates should be considered
@return ETrue if the fix fulfills the requirements,
*/
TBool CNETResponseHandler::GetLastPosition(TPositionInfoBase& aPos, TTime aOldestValidTime, TBool aAllowPartial)
{
TBool ret = EFalse;
TTime actualTime;
TPositionInfo posInfo;
TPosition pos;
TInt err;
err = iNETDataBus->GetLastPositionInfo(posInfo, actualTime);
if( err == KErrNone && actualTime >= aOldestValidTime) // got a recent enough position
{
posInfo.GetPosition(pos);
if(aAllowPartial || !Partial(pos))// complete enough
{
TRAPD(error, CopyPositionTypes(aPos, posInfo));
if(!error)
{
ret = ETrue;
}
else
{
LBSLOG(ELogP1, "CNetResponseHandler::GetLastPosition() failed to copy position ");
ret = EFalse;
}
}
}
return ret;
}
//
// This test checks that a SetLastKnowPosition request
// results in a request to store a position sent to the DB
//
TVerdict CTe_LocMonitorStep11::doTestStepL()
{
if (TestStepResult()==EPass)
{
TPositionInfo positionInfo;
TPosition position;
TReal64 latitude(11), longitude(21);
position.SetCoordinate(latitude, longitude);
positionInfo.SetPosition(position);
RLbsLocMonitorSession locMonSession;
User::LeaveIfError(locMonSession.Connect());
RLbsLocMonitorAreaPositioner areaPositioner;
areaPositioner.OpenL(locMonSession);
CleanupClosePushL(areaPositioner);
iLocMonDbListener->ListenForLocMonDbFeedback();
areaPositioner.SetLastKnownPosition(positionInfo);
iLocMonDbListener->WaitForDbFeedback();
// Check that the position received by the DB is the position
// sent by the test
TESTL(latitude == iLocMonDbListener->iDbData.iPosition.Latitude());
TESTL(longitude == iLocMonDbListener->iDbData.iPosition.Longitude());
CleanupStack::PopAndDestroy(&areaPositioner);
locMonSession.Close();
}
return TestStepResult();
}
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);
}
// ---------------------------------------------------------
// CT_LbsInstallPsyTp273::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsInstallPsyTp273::NotifyPositionUpdate(
TPositionInfoBase& aPosInfo,
TRequestStatus& aStatus)
{
TInt err = KErrNone;
TTime tt;
tt.UniversalTime();
//Request ID must be unique, use universalime as seed
// to give a random number
TInt64 seed = tt.Int64();
TReal lat = 90 * Math::FRand(seed);
TReal lon = 90 * Math::FRand(seed);
TReal32 alt = (TReal32)(90 * Math::FRand(seed));
TPositionInfo* position = static_cast<TPositionInfo*> (&aPosInfo);
TUid implUid = { KPosImplementationUid };
position->SetModuleId(implUid);
TTime now;
now.UniversalTime();
TPosition posse;
posse.SetCoordinate(lat, lon, alt);
posse.SetTime(now);
position->SetPosition(posse);
TRequestStatus* status = &aStatus;
User::RequestComplete(status, err);
}
// ---------------------------------------------------------
// CT_LbsTestPsySimulateIsa::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsTestPsySimulateIsa::NotifyPositionUpdate(
TPositionInfoBase& aPosInfo,
TRequestStatus& /*aStatus*/)
{
TPositionInfo* iPosition = static_cast<TPositionInfo*> (&aPosInfo);
TUid implUid = { KPosImplementationUid };
iPosition->SetModuleId(implUid);
}
// ---------------------------------------------------------
// CT_LbsStubPositioner::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsStubPositioner::NotifyPositionUpdate(
TPositionInfoBase& aPosInfo,
TRequestStatus& aStatus)
{
TPositionInfo* position = static_cast<TPositionInfo*> (&aPosInfo);
TUid implUid = { KPosImplementationUid };
position->SetModuleId(implUid);
TRequestStatus* status = &aStatus;
User::RequestComplete(status, KErrNone);
}
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);
}
// ---------------------------------------------------------
// CTestPsy4Positioner::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsTestProxyPsy4Positioner::NotifyPositionUpdate(TPositionInfoBase& aPosInfo, TRequestStatus& aStatus)
{
TPositionInfo* posInfo = static_cast<TPositionInfo*> (&aPosInfo);
TUint32 request = posInfo->UpdateType();
switch (request)
{
case 12:
iRequestHandler->SetErrorCode(KErrNone);
break;
default:
iRequestHandler->SetErrorCode(KErrUnknown);
break;
}
iRequestHandler->NotifyPositionUpdate(posInfo, &aStatus);
}
void CT_LbsPTBMTLRCancel::ProcessNetworkPositionUpdate(TUint /*aRequestId*/, const TPositionInfo& aPosInfo)
{
if(iState==EPrivacyCheckOk)
{
// check that it is the REF postion we are expecting!
if (aPosInfo.PositionMode() == TPositionModuleInfo::ETechnologyNetwork)
{
TPosition getPos;
aPosInfo.GetPosition(getPos);
if (getPos.Longitude()==-0.096) // and others ...
{
iState=ERefLocReceived;
}
}
INFO_PRINTF1(_L(">>CT_LbsPTBMTLRCancel::ProcessNetworkPositionUpdate(RefPosition)"));
}
ReturnToTestStep();
}
void CNetworkPsy2::CompleteRequestByDefault()
{
if(!iRequestStatus)
{
return;
}
if(iPositionInfoBase->PositionClassType() & EPositionInfoClass)
{
TPositionInfo* posInfo = static_cast<TPositionInfo*>(iPositionInfoBase);
TPosition pos;
pos.SetCoordinate(1.0, 1.0, 1.0);
pos.SetAccuracy(1.0, 1.0);
posInfo->SetPosition(pos);
}
CompleteRequest(KErrNone);
}
/**
Get the last position from the bus
*/
TInt CFinalNetDataBus::GetLastPositionInfo(TPositionInfo& aFNPInfo, TTime& aActualTime)
{
TLbsNetSessionIdInt sessionId;
TTime targetTime;
TInt error = iFinalNetDataBus.GetPositionInfo(sessionId, aFNPInfo, targetTime, aActualTime);
if(error == KErrNone && (aFNPInfo.PositionMode() & TPositionModuleInfo::ETechnologyTerminal))
{
error = KErrNotFound; // filter out terminal assisted FNPs
}
return error;
}
QGeoPositionInfo CPsyContainer::lastKnownPosition(bool aFromSatellitePositioningMethodsOnly)
{
QGeoPositionInfo posUpdate;
TPosition pos;
TInt error = KErrNone;
RPositioner lastKnownpositioner;
TRequestStatus status;
error = lastKnownpositioner.Open(PosServer());
//request for lastknown position update and wait for the request to complete
if (error == KErrNone) {
TPositionInfo posInfo;
lastKnownpositioner.SetRequestor(CRequestor::ERequestorService ,
CRequestor::EFormatApplication, _L("QTmobility_Location"));
lastKnownpositioner.GetLastKnownPosition(posInfo, status);
//Sub-optimal implementation inherited from the previous implementation
//Since this is a 'once in a while' usecase, this should be ok
//An optimal implementation will be much more complex and will need changes
//in the symbian locaiton stack
User::WaitForRequest(status);
error = status.Int();
lastKnownpositioner.Close();
if ((error == KErrNone) || (error == KPositionPartialUpdate)) {
TPositionModuleInfo modInfo;
iPosServer.GetModuleInfoById(posInfo.ModuleId(), modInfo);
if (!aFromSatellitePositioningMethodsOnly ||
(aFromSatellitePositioningMethodsOnly && (modInfo.Capabilities() & TPositionModuleInfo::ECapabilitySatellite))) {
PsyUtils::TPositionInfo2QGeoPositionInfo(posInfo, posUpdate);
}
}
}
return posUpdate;
}
void CLcfPsyDummy1::GetBasicPositionInfoL(TPositionInfoBase& aPosInfo)
{
// The position info object is at least a TPositionInfo
TPositionInfo* posInfo =
static_cast<TPositionInfo*>(&aPosInfo);
TPosition pos;
// Calculate the position and fill in the position info
// object
// Latitude, Longtitude, altitude
pos.SetCoordinate(57.1, 11.3, 32.5);
// set horizontal and vertical accuracy
pos.SetAccuracy(40.0, 40.0);
// set time of fix
pos.SetCurrentTime();
// Set position in position info.
posInfo->SetPosition(pos);
// Set the implementation uid
posInfo->SetModuleId(ImplementationUid());
}
/** Called at the end of the test to verify the correct position data has been returned to the
client.
Each test case SHOULD implement a version of this.
*/
void CT_LbsConflictStep_X3PMenuPush::VerifyPosInfos()
{
T_LbsUtils utils;
RPointerArray<TAny>& verifyPosInfoArr = iParent.iSharedData->iVerifyPosInfoArr;
RPointerArray<TAny>& currPosInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
TPositionInfo* currPosInfo;
// Verify both the self locate and X3P MOLR position information.
// Verify entry 0 for the self locate. We expect a position containing NaNs.
currPosInfo = reinterpret_cast<TPositionInfo*>(currPosInfoArr[0]);
TPosition pos;
currPosInfo->GetPosition(pos);
if (!Math::IsNaN(pos.Latitude()))
{
INFO_PRINTF1(_L("Failed test, Position does not contain NANs"));
SetTestStepResult(EFail);
}
if (!Math::IsNaN(pos.Longitude()))
{
INFO_PRINTF1(_L("Failed test, Position does not contain NANs"));
SetTestStepResult(EFail);
}
// Verify entry 1 for the X3P. We expect a real location value, compare using the data
// sent to the test APGS module.
TPositionInfo* verifyPosInfo = reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0]);
currPosInfo = reinterpret_cast<TPositionInfo*>(currPosInfoArr[1]);
if (!utils.Compare_PosInfo(*verifyPosInfo, *currPosInfo))
{
INFO_PRINTF1(_L("Failed test, X3P position incorrect."));
SetTestStepResult(EFail);
}
}
void CLcfPsyDummy3::GetBasicPositionInfoL(TPositionInfoBase& aPosInfo)
{
// The position info object is at least a TPositionInfo
TPositionInfo* posInfo =
static_cast<TPositionInfo*>(&aPosInfo);
TPosition pos;
// Calculate the position and fill in the position info
// object
pos.SetCoordinate(67.567, -12.34, 45.32);
// set horizontal and vertical accuracy
pos.SetAccuracy(150.0, 500.0);
// set time of fix
pos.SetCurrentTime();
// Set position in position info.
posInfo->SetPosition(pos);
// Set the implementation uid
posInfo->SetModuleId(ImplementationUid());
}
void CT_LbsHybridUEAssistedMTLRTimeout::ProcessNetworkPositionUpdate(TUint /*aRequestId*/, const TPositionInfo& aPosInfo)
{
if(iState==EPrivacyCheckOk)
{
iState=ERefLocReceived;
INFO_PRINTF1(_L(">>CT_LbsHybridUEAssistedMTLRTimeout::ProcessNetworkPositionUpdate(RefPosition)"));
}
else if(iState==ERefLocReceived)
{
// Test for $update,1,2,51.5015,-0.105,50,2,3*
TPosition getPos;
aPosInfo.GetPosition(getPos);
if(getPos.Latitude()==51.5015 && getPos.Longitude()==-0.105 && getPos.Altitude()==50 && getPos.HorizontalAccuracy()==2 && getPos.VerticalAccuracy()==3)
{
INFO_PRINTF1(_L(">>CT_LbsHybridUEAssistedMTLRTimeout::ProcessNetworkPositionUpdate(GpsPosition)"));
iState=EGpsLocReceived;
}
}
ReturnToTestStep();
}
EXPORT_C void MTe_LbsPsyStaticData::PrintPosInfo(const TPositionInfo& aPosInfo) const
{
_LIT(KTimeFormat, "%H:%T:%S.%C");
TBuf<100> cTimeStr;
INFO_PRINTF2(_L("classSize=%d"), aPosInfo.PositionClassSize());
INFO_PRINTF2(_L("classType=0x%x"), aPosInfo.PositionClassType());
INFO_PRINTF2(_L("moduleId=0x%x"), aPosInfo.ModuleId());
INFO_PRINTF2(_L("updateType=%d"), aPosInfo.UpdateType());
INFO_PRINTF2(_L("positionMode=%d"), aPosInfo.PositionMode());
INFO_PRINTF2(_L("positionModeReason=%d"), aPosInfo.PositionModeReason());
TPosition pos;
aPosInfo.GetPosition(pos);
INFO_PRINTF2(_L("pos altitude=%f"), pos.Altitude());
INFO_PRINTF2(_L("pos latitude=%f"), pos.Latitude());
INFO_PRINTF2(_L("pos longitude=%f"), pos.Longitude());
INFO_PRINTF2(_L("pos datum=0x%x"), pos.Datum());
INFO_PRINTF2(_L("pos horAccuracy=%f"), pos.HorizontalAccuracy());
INFO_PRINTF2(_L("pos verAccuracy=%f"), pos.VerticalAccuracy());
TRAP_IGNORE(pos.Time().FormatL(cTimeStr, KTimeFormat);)
/**
* Verifies that the supplied position is 'reasonable'
*
*/
EXPORT_C TBool T_LbsUtils::Verify_PositionIsValid(TPositionInfo& aPosInfo)
{
TBool valid = TRUE;
TPosition pos;
TReal32 alt;
TReal64 lat, longt;
aPosInfo.GetPosition(pos);
alt = pos.Altitude();
lat = pos.Latitude();
longt = pos.Longitude();
// TO DO figure out what values are reasonable here (in Milton somewhere!?)
// We could use the normal verify posinfo stuff, and check to see if the values are roughly equal.
// Either update this func (add a parameter) or new func like the compare posinfo func we have
if(alt == 0 || lat == 0 || longt == 0)
{
valid = FALSE;
}
return valid;
}
TVerdict CT_LbsHybridUEBasedX3PGPSFutile::doTestStepL()
{
// Generic test step used to test the LBS Client Notify position update API.
INFO_PRINTF1(_L("CT_LbsHybridUEBasedX3PGPSFutile::doTestStepL()"));
// Stop the test if the preamble failed
TESTL(TestStepResult() == EPass);
const TInt KTimeOut = 30*1000*1000;
const TInt KAdviceSystemStatusTimeout = 40*1000*1000;
const TInt KSmallTimeOut = 3*1000*1000;
// Carryout unique test actions.
if (GetIntFromConfig(ConfigSection(), KTestCaseId, iTestCaseId))
{
INFO_PRINTF2(_L("Test id %d."), iTestCaseId);
}
// >> AdviceSystemStatus(0)
TESTL(iProxy->WaitForResponse(KAdviceSystemStatusTimeout) == ENetMsgGetCurrentCapabilitiesResponse);
CLbsNetworkProtocolBase::TLbsSystemStatus status;
CleanupStack::PopAndDestroy(iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status));
TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
//Initiate X3P start
// TransmitPosition()
_LIT(KThirdParty,"+4407463842101");
const TInt KPriority= 1;
TLbsTransmitPositionOptions options(TTimeIntervalMicroSeconds(50*1000*1000));
TRequestStatus refPosStatus=KRequestPending;
TRequestStatus transPosStatus=KRequestPending;
TPositionInfo refPosInfo;
TPositionInfo transPosInfo;
iTransmitter.SetTransmitOptions(options);
iTransmitter.TransmitPosition(KThirdParty, KPriority, refPosStatus, refPosInfo, transPosStatus, transPosInfo);
// RequestTransmitLocation()
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRequestTransmitLocation);
TBufC16<14> thirdParty(KThirdParty);
TPtr16 ptr = thirdParty.Des();
HBufC16* getThirdParty = NULL;
TLbsNetSessionId* getSessionId = NULL;
TInt getPriority(0);
TInt cleanupCnt;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestTransmitLocation, &getSessionId, &getThirdParty, &getPriority);
TESTL(ptr.Compare(*getThirdParty)==KErrNone);
TESTL(getPriority == KPriority);
iSessionId = *getSessionId; //session ID is initialised by LBS
CleanupStack::PopAndDestroy(cleanupCnt);
// ProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceTransmitThirdParty;
iProxy->CallL(ENetMsgProcessStatusUpdate, &service);
//End Initiate
//Reference Position Notification Start
// ProcessLocationUpdate()
refPosInfo = ArgUtils::ReferencePositionInfo();
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
//Reference Position Notification End
//Assistance Data Notification Start
// ProcessAssistanceData()
TLbsAsistanceDataGroup dataRequestMask = EAssistanceDataReferenceTime;
RLbsAssistanceDataBuilderSet assistanceData;
ArgUtils::PopulateLC(assistanceData);
TInt reason = KErrNone;
iProxy->CallL(ENetMsgProcessAssistanceData, &dataRequestMask, &assistanceData, &reason);
CleanupStack::PopAndDestroy(1); //assistanceData
// Assistance Data Notification End
// Network Location Request Start
// ProcessLocationRequest()
const TBool emergency(EFalse);
TLbsNetPosRequestQuality quality = ArgUtils::QualityAlpha2();
TLbsNetPosRequestMethod method;
if (iTestCaseId == 1)
{
method = ArgUtils::RequestHybridMethod();
}
else if (iTestCaseId == 2)
{
method = ArgUtils::RequestMethod();
}
iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
// Network Location Request Stop
// RequestAssistanceData(0)
TESTL(iProxy->WaitForResponse(KSmallTimeOut) == ENetMsgRequestAssistanceData);
TLbsAsistanceDataGroup dataGroup;
CleanupStack::PopAndDestroy(iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup));
TESTL(dataGroup == EAssistanceDataNone);
// User expects Reference Position
User::WaitForRequest(refPosStatus);
TESTL(refPosStatus==KErrNone);
// Network expects location request response with KPositionCalculationFutile
TESTL(iProxy->WaitForResponse(KAlpha2Timeout) == ENetMsgRespondLocationRequest);
getSessionId = NULL;
TInt getReason = KErrNone;
TPositionSatelliteInfo* getPositionInfo = NULL;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);
TESTL(getSessionId->SessionNum() == iSessionId.SessionNum());
TESTL(getReason==KPositionCalculationFutile);
CleanupStack::PopAndDestroy(cleanupCnt);
// Network Result Notification Start
// ProcessLocationUpdate() , final network position = ref position
refPosInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
// Network Result Notification Stop
// Session Complete Start
reason =KErrNone;
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceNone;
iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask);
// Session Complete Stop
// this call back has been changed, the seq diag was incorrect
User::WaitForRequest(transPosStatus);
TESTL(transPosStatus==KPositionQualityLoss);
return TestStepResult();
}
void CT_LbsNetProtocol::RunL()
{
TInt response(iStatus.Int());
switch(iNetworkProtocolProxyStep)
{
case ENetworkProtocolProxyStepInitial:
{
switch(response)
{
case ENetMsgCancelSelfLocation:
{
// >> CancelSelfLocation()
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgGetCurrentCapabilitiesResponse:
{
// >> AdviceSystemStatus()
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
iStep.TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone || status == CLbsNetworkProtocolBase::ESystemStatusClientTracking);
if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
}
else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
}
CleanupStack::PopAndDestroy(cleanupCnt);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgRequestAssistanceData:
{
// >> RequestAssistanceData(0)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
TLbsAsistanceDataGroup dataMask;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
iStep.TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgTimeoutExpired:
{ // can happen that no request has been sent through, so start waiting again
if(iClientsFinished)
{
iObserver.StopTest();
}
else
{
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
break;
}
case ENetMsgRequestSelfLocation:
{
Process_RequestSelfLocationL();
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
default:
{
iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepInitial received unexpected response: %d"), response);
User::Leave(KErrNotSupported);
}
}
break;
}
case ENetworkProtocolProxyStepSessionNrhRequestSent:
{
switch(response)
{
case ENetMsgRequestAssistanceData:
{
// >> RequestAssistanceData(0)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
TLbsAsistanceDataGroup dataMask;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
iStep.TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
DecideWhatNetworkDoesntReceive();
if(iNetworkExpectsMeasurments)
{ // measurements should be sent to the network
// Determine the value to take off the alpha2 value. This is required because we had to wait for the assistance data response.
TTimeIntervalMicroSeconds microseconds;
TTime stopTime;
stopTime.HomeTime();
microseconds = stopTime.MicroSecondsFrom(iAlpha2StartTime);
TInt64 timeElapsed = microseconds.Int64();
// Test that we do not get response before alpha2 has expired:
TInt timeOut = KAlphaTimer - timeElapsed - KDelta > 0 ? KAlphaTimer - timeElapsed - KDelta : 0;
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionWaitingForFirstMeasurmentsTimeOut;
iProxy->WaitForResponseL(timeOut, iStatus);
SetActive();
}
else
{
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionMeasurmentsReceived;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
break;
}
case ENetMsgCancelSelfLocation:
{
// >> CancelSelfLocation()
TLbsNetSessionId* sessionId = NULL;
TInt cancelReason = KErrNone;
TInt cleanupCnt;
cleanupCnt = iProxy->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &cancelReason);
if(sessionId->SessionNum() == iSessionId.SessionNum())
{ // should complete the session
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation()"));
CleanupStack::PopAndDestroy(cleanupCnt);
// << ProcessSessionComplete()
TInt reason = KErrNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
// << ProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));
iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
else
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
iStep.TESTL(sessionId->SessionNum() < iSessionId.SessionNum());
CleanupStack::PopAndDestroy(cleanupCnt);
sessionId = NULL;
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionWaitingForFirstMeasurments;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
break;
}
case ENetMsgGetCurrentCapabilitiesResponse:
{
// >> AdviceSystemStatus()
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
}
else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
}
else
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus() with wrong status"));
User::Leave(KErrNotSupported);
}
CleanupStack::PopAndDestroy(cleanupCnt);
iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgRequestSelfLocation:
{
Process_RequestSelfLocationL();
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
default:
{
iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionNrhRequestSent received unexpected response: %d"), response);
User::Leave(KErrNotSupported);
}
}
break;
}
case ENetworkProtocolProxyStepSessionWaitingForFirstMeasurmentsTimeOut:
{
switch(response)
{
case ENetMsgRequestAssistanceData:
{
// >> RequestAssistanceData(0)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
TLbsAsistanceDataGroup dataMask;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
iStep.TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
TTimeIntervalMicroSeconds microseconds;
TTime stopTime;
stopTime.HomeTime();
microseconds = stopTime.MicroSecondsFrom(iAlpha2StartTime);
TInt64 timeElapsed = microseconds.Int64();
// Test that we do not get response before alpha2 has expired:
TInt timeOut = KAlphaTimer - timeElapsed - KDelta > 0 ? KAlphaTimer - timeElapsed - KDelta : 0;
iProxy->WaitForResponseL(timeOut, iStatus);
SetActive();
break;
}
case ENetMsgGetCurrentCapabilitiesResponse:
{
// >> AdviceSystemStatus()
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
}
else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
}
else
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus() with wrong status"));
User::Leave(KErrNotSupported);
}
CleanupStack::PopAndDestroy(cleanupCnt);
TTimeIntervalMicroSeconds microseconds;
TTime stopTime;
stopTime.HomeTime();
microseconds = stopTime.MicroSecondsFrom(iAlpha2StartTime);
TInt64 timeElapsed = microseconds.Int64();
// Test that we do not get response before alpha2 has expired:
TInt timeOut = KAlphaTimer - timeElapsed - KDelta > 0 ? KAlphaTimer - timeElapsed - KDelta : 0;
iProxy->WaitForResponseL(timeOut, iStatus);
SetActive();
break;
}
case ENetMsgCancelSelfLocation:
{
// >> CancelSelfLocation()
TLbsNetSessionId* sessionId = NULL;
TInt cancelReason = KErrNone;
TInt cleanupCnt;
cleanupCnt = iProxy->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &cancelReason);
if(sessionId->SessionNum() == iSessionId.SessionNum())
{ // should complete the session
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation()"));
CleanupStack::PopAndDestroy(cleanupCnt);
// << ProcessSessionComplete()
TInt reason = KErrNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
// << ProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));
iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
else
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
iStep.TESTL(sessionId->SessionNum() < iSessionId.SessionNum());
CleanupStack::PopAndDestroy(cleanupCnt);
sessionId = NULL;
TTimeIntervalMicroSeconds microseconds;
TTime stopTime;
stopTime.HomeTime();
microseconds = stopTime.MicroSecondsFrom(iAlpha2StartTime);
TInt64 timeElapsed = microseconds.Int64();
// Test that we do not get response before alpha2 has expired:
TInt timeOut = KAlphaTimer - timeElapsed - KDelta > 0 ? KAlphaTimer - timeElapsed - KDelta : 0;
iProxy->WaitForResponseL(timeOut, iStatus);
SetActive();
}
break;
}
case ENetMsgTimeoutExpired:
{
// >> Alpha2 timeout
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy - Network expecting measurements after timeout"));
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionWaitingForFirstMeasurments;
iProxy->WaitForResponseL(2 * 1000* KDelta, iStatus);
SetActive();
break;
}
case ENetMsgRespondLocationRequest:
{ // If the module sends an accurate enough position then the Alpha2 timer might not time-out so check we received positions
// >> RespondLocationRequest(gpspos)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RespondLocationRequest(gpspos)"));
RequestNetworkMethod();
DecideWhatNetworkDoesntReceive();
iStep.TESTL(iNetworkExpectsPositions);
TLbsNetSessionId* sessionId = NULL;
TPositionInfo* positionInfo = NULL;
TInt reason;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo);
// check it is a position
iStep.TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass|EPositionExtendedSatelliteInfoClass));
iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
iStep.TESTL(reason == KErrNone);
// << ProcessLocationUpdate(FNP)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationUpdate(SessionId, FinalNetworkPosition)"));
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, positionInfo);
CleanupStack::PopAndDestroy(cleanupCnt);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
SetActive();
break;
}
default:
{
iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionWaitingForFirstMeasurmentsTimeOut received unexpected response: %d"), response);
User::Leave(KErrNotSupported);
}
}
break;
}
case ENetworkProtocolProxyStepSessionWaitingForFirstMeasurments:
{
switch(response)
{
case ENetMsgRequestAssistanceData:
{
// >> RequestAssistanceData(0)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
TLbsAsistanceDataGroup dataMask;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
iStep.TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgCancelSelfLocation:
{
// >> CancelSelfLocation()
TLbsNetSessionId* sessionId = NULL;
TInt cancelReason = KErrNone;
TInt cleanupCnt;
cleanupCnt = iProxy->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &cancelReason);
if(sessionId->SessionNum() == iSessionId.SessionNum())
{ // should complete the session
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation()"));
CleanupStack::PopAndDestroy(cleanupCnt);
// << ProcessSessionComplete()
TInt reason = KErrNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
// << ProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));
iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
else
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
iStep.TESTL(sessionId->SessionNum() < iSessionId.SessionNum());
CleanupStack::PopAndDestroy(cleanupCnt);
sessionId = NULL;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
break;
}
case ENetMsgRespondLocationRequest:
{
// >> RespondLocationRequest(meas)
TLbsNetSessionId* sessionId = NULL;
TPositionInfo* positionInfo = NULL;
TInt reason;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo);
RequestNetworkMethod();
DecideWhatNetworkDoesntReceive();
// check it is a position
if(positionInfo->PositionClassType() == EPositionGpsMeasurementInfoClass)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RespondLocationRequest(meas)"));
iStep.TESTL(iNetworkExpectsMeasurments);
iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); // module sends NAN measurement first
if(reason != KErrNone)
{
iStep.INFO_PRINTF2(_L("NetworkProtocolProxy reason = 0x%x"), reason);
}
iStep.TESTL(reason == KErrNone);
CleanupStack::PopAndDestroy(cleanupCnt);
if(iPlannedPositionOriginator == EPositionOriginatorModule)
{
if(iNetworkExpectsPositions)
{
// << ProcessLocationRequest(SessionId, HybridMode, t)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationRequest(SessionId, HybridMode, t)"));
TBool emergency = EFalse;
MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
TLbsNetPosRequestQuality quality = ArgUtils::Quality();
quality.SetMaxFixTime(KT);
TLbsNetPosRequestMethod method = RequestNetworkMethod();
iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionMeasurmentsReceived;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
else
{
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
SetActive();
}
}
else if(iPlannedPositionOriginator == EPositionOriginatorNetwork)
{
TPositionInfo positionInfo = ArgUtils::AccurateNetworkPositionInfo();
// << ProcessLocationUpdate(SessionId, FinalNetworkPosition)
// Return FinalNetworkPosition
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationUpdate(SessionId, FNP)"));
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &positionInfo);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
SetActive();
}
}
else
{
// >> RespondLocationRequest(gpspos)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RespondLocationRequest(gpspos)"));
// check it is a position
iStep.TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass|EPositionExtendedSatelliteInfoClass));
iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
iStep.INFO_PRINTF3(_L("NetworkProtocolProxy reason = %d(0x%x)"), reason,reason);
if(reason != KErrPositionNoGpsUpdate)
{
iStep.TESTL(reason == KErrNone);
}
iStep.TESTL(iNetworkExpectsPositions);
// << ProcessLocationUpdate(FNP)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationUpdate(SessionId, FinalNetworkPosition)"));
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, positionInfo);
CleanupStack::PopAndDestroy(cleanupCnt);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
SetActive();
}
break;
}
default:
{
iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionWaitingForFirstMeasurments received unexpected response: %d"), response);
User::Leave(KErrNotSupported);
}
}
break;
}
case ENetworkProtocolProxyStepSessionMeasurmentsReceived:
{
switch(response)
{
case ENetMsgRequestAssistanceData:
{
// >> RequestAssistanceData(0)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
TLbsAsistanceDataGroup dataMask;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
iStep.TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgRespondLocationRequest:
{ // If the module sends an accurate enough position then the Alpha2 timer might not time-out so check we received positions
// >> RespondLocationRequest(gpspos/meas)
TLbsNetSessionId* sessionId = NULL;
TPositionInfo* positionInfo = NULL;
TInt reason;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo);
RequestNetworkMethod();
DecideWhatNetworkDoesntReceive();
// check it is a position
if(positionInfo->PositionClassType() == EPositionGpsMeasurementInfoClass)
{ // received more measurments
// >> RespondLocationRequest(meas)
iStep.TESTL(iNetworkExpectsMeasurments);
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RespondLocationRequest(meas)"));
iStep.TESTL(iNetworkExpectsMeasurments);
iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); // module sends NAN measurement first
if(reason != KErrNone)
{
iStep.INFO_PRINTF2(_L("NetworkProtocolProxy reason = 0x%x"), reason);
}
iStep.TESTL(reason == KErrNone);
iStep.TESTL(iPlannedPositionOriginator == EPositionOriginatorModule);
iStep.TESTL(iNetworkExpectsPositions);
// << ProcessLocationRequest(SessionId, HybridMode, t)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationRequest(SessionId, HybridMode, t)"));
TBool emergency = EFalse;
MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
TLbsNetPosRequestQuality quality = ArgUtils::Quality();
quality.SetMaxFixTime(KT);
TLbsNetPosRequestMethod method = RequestNetworkMethod();
iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
else
{ // received a position
iStep.TESTL(iNetworkExpectsPositions);
iStep.TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass|EPositionExtendedSatelliteInfoClass));
iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
iStep.TESTL(reason == KErrNone);
// << ProcessLocationUpdate(FNP)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationUpdate(SessionId, FinalNetworkPosition)"));
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, positionInfo);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
SetActive();
}
CleanupStack::PopAndDestroy(cleanupCnt);
break;
}
default:
{
iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionMeasurmentsReceived received unexpected response: %d"), response);
User::Leave(KErrNotSupported);
}
}
break;
}
case ENetworkProtocolProxyStepSessionPositionSent:
{
switch(response)
{
case ENetMsgRequestAssistanceData:
{
// >> RequestAssistanceData(0)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
TLbsAsistanceDataGroup dataMask;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
iStep.TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgGetCurrentCapabilitiesResponse:
{
// >> AdviceSystemStatus()
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
}
else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
}
else
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus() with wrong status"));
User::Leave(KErrNotSupported);
}
CleanupStack::PopAndDestroy(cleanupCnt);
iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgCancelSelfLocation:
{
// >> CancelSelfLocation()
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() - as result of FNP"));
// << ProcessSessionComplete()
TInt reason = KErrNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
// << ProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));
iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgTimeoutExpired:
{
// << ProcessSessionComplete()
TInt reason = KErrNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
// << ProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));
iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgRequestSelfLocation:
{
Process_RequestSelfLocationL();
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
default:
{
iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionPositionSent received unexpected response: %d"), response);
User::Leave(KErrNotSupported);
}
}
break;
}
case ENetworkProtocolProxyStepNoSessionRunning:
{
switch(response)
{
case ENetMsgCancelSelfLocation:
{
// >> CancelSelfLocation()
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgTimeoutExpired:
{ // can happen that no request has been sent through, so start waiting again
if(iClientsFinished)
{
iObserver.StopTest();
}
else
{
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
}
break;
}
case ENetMsgRequestAssistanceData:
{
// >> RequestAssistanceData(0)
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
TLbsAsistanceDataGroup dataMask;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
iStep.TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgGetCurrentCapabilitiesResponse:
{
// >> AdviceSystemStatus()
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
}
else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
}
else
{
iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus() with wrong status"));
User::Leave(KErrNotSupported);
}
CleanupStack::PopAndDestroy(cleanupCnt);
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
case ENetMsgRequestSelfLocation:
{
Process_RequestSelfLocationL();
iProxy->WaitForResponseL(KTimeOut, iStatus);
SetActive();
break;
}
default:
{
iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepNoSessionRunning received unexpected response: %d"), response);
User::Leave(KErrNotSupported);
}
}
break;
}
default:
{
iStep.INFO_PRINTF1(_L("Network in unexpected state"));
User::Leave(KErrCorrupt);
}
}
iObserver.OnSignalNetworkStep(iRelativeSessionId, iNetworkProtocolProxyStep);
}
// ---------------------------------------------------------
// CTestPsy2Positioner::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsTestProxyPsy2Positioner::NotifyPositionUpdate(TPositionInfoBase& aPosInfo, TRequestStatus& aStatus)
{
TBuf<256> buf;
OpenFileForAppend();
_LIT(KTestProxyPsy2Positioner, " Request issued to TestProxyPsy2Positioner");
buf.Append(KTestProxyPsy2Positioner);
_LIT(KAppend, "\r");
buf.Append(KAppend);
iFileText.Write(buf);
iFile.Close();
TRequestStatus* status = &aStatus;
TPositionInfo* posInfo = static_cast<TPositionInfo*> (&aPosInfo);
TPosition pos;
pos.SetCoordinate(10, 20, 30);
posInfo->SetPosition(pos);
TUid implUid = { KPosImplementationUid };
posInfo->SetModuleId(implUid);
TUint32 request = posInfo->UpdateType();
switch (request)
{
// case 1-10 - TC269
// case 11-15 - TC270
// case 21-26 - TC271
case 1:
case 5:
case 12:
case 13:
case 14:
case 21:
case 23:
case 24:
User::RequestComplete( status, KPositionPartialUpdate);
break;
case 2:
case 3:
case 4:
case 11:
case 15:
case 22:
User::RequestComplete( status, KErrLocked);
break;
case 6:
case 9:
case 10:
case 25:
User::RequestComplete( status, KErrDied);
break;
case 7:
case 8:
case 26:
User::RequestComplete( status, KErrBadPower);
break;
case 4701:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(2000000);
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 4702:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(3000000);
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 4703:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(2000000);
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 4704:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(3000000);
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 4708:
case 304:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(1000000); // 1 second
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 100:
iRequestHandler->ReportStatus(
TPositionModuleStatus::EDeviceInitialising,
TPositionModuleStatus::EDataQualityUnknown);
User::RequestComplete( status, KErrNone );
break;
case 200:
iRequestHandler->ReportStatus(
TPositionModuleStatus::EDeviceActive,
TPositionModuleStatus::EDataQualityUnknown);
User::RequestComplete( status, KErrNone );
break;
default:
User::RequestComplete( status, KErrDied);
break;
}
}
TVerdict CT_LbsX3pAccRefPos::doTestStepL()
{
// Generic test step used to test the LBS Client Notify position update API.
INFO_PRINTF1(_L("CT_LbsX3pAccRefPos::doTestStepL()"));
// Stop the test if the preamble failed
TESTL(TestStepResult() == EPass);
const TInt KTimeOut = 30*1000*1000;
const TInt KAdviceSystemStatusTimeout = 40*1000*1000;
// >> AdviceSystemStatus(0)
TESTL(iProxy->WaitForResponse(KAdviceSystemStatusTimeout) == ENetMsgGetCurrentCapabilitiesResponse);
CLbsNetworkProtocolBase::TLbsSystemStatus status;
// nothing is placed on cleanupstack for ENetMsgGetCurrentCapabilitiesResponse
CleanupStack::PopAndDestroy(iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status));
TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
//Initiate X3P start
// TransmitPosition()
_LIT(KThirdParty,"+4407463842101");
const TInt KPriority(6);
TLbsTransmitPositionOptions options(TTimeIntervalMicroSeconds(50*1000*1000));
TRequestStatus refPosStatus=KRequestPending;
TRequestStatus transPosStatus=KRequestPending;
TPositionInfo clientRefPosInfo;
TPositionInfo transPosInfo;
iTransmitter.SetTransmitOptions(options);
iTransmitter.TransmitPosition(KThirdParty, KPriority, refPosStatus, clientRefPosInfo, transPosStatus, transPosInfo);
// RequestTransmitLocation()
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRequestTransmitLocation);
TBufC16<14> thirdParty(KThirdParty);
TPtr16 ptr = thirdParty.Des();
HBufC16* getThirdParty = NULL;
TLbsNetSessionId* getSessionId = NULL;
TInt getPriority(0);
TInt stackCnt =
iProxy->GetArgsLC(ENetMsgRequestTransmitLocation, &getSessionId, &getThirdParty, &getPriority);
TESTL(ptr.Compare(*getThirdParty)==KErrNone);
TESTL(getPriority == KPriority);
iSessionId = *getSessionId; //session ID is initialised by LBS
CleanupStack::PopAndDestroy(stackCnt);//getSessionID,getThirdParty
// ProcessStatusUpdate()
const MLbsNetworkProtocolObserver::TLbsNetProtocolService service
= MLbsNetworkProtocolObserver::EServiceTransmitThirdParty;
iProxy->CallL(ENetMsgProcessStatusUpdate, &service);
//End Initiate
//Reference Position Notification Start
// ProcessLocationUpdate()
TPositionInfo refPosInfo;
refPosInfo = ArgUtils::ReferencePositionInfo();
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
//Reference Position Notification End
//Assistance Data Notification Start
// ProcessAssistanceData()
TLbsAsistanceDataGroup dataRequestMask = EAssistanceDataReferenceTime;
RLbsAssistanceDataBuilderSet assistanceData;
ArgUtils::PopulateLC(assistanceData);
TInt reason(KErrNone);
iProxy->CallL(ENetMsgProcessAssistanceData, &dataRequestMask, &assistanceData, &reason);
CleanupStack::PopAndDestroy(1); //assistanceData
// Assistance Data Notification End
// Network Result Notification Start
// ProcessLocationUpdate()
//Final Network Position = ref position
refPosInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
// Network Result Notification Stop
// Session Complete Start
reason = KErrNone;
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceNone;
iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask);
// Session Complete Stop
// Allow session complete to be processed by LBS.
TInt delta = 4 * 1000 * 1000; // 4 secs.
TESTL(iProxy->WaitForResponse(delta) == ENetMsgTimeoutExpired);
// Complete client request.
User::WaitForRequest(refPosStatus, transPosStatus);
// Verify client ref pos.
TESTL(clientRefPosInfo.PositionMode() == TPositionModuleInfo::ETechnologyNetwork);
TESTL(refPosStatus == KErrNone);
// Verify client final pos.
TESTL(transPosInfo.PositionMode() == (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted));
TESTL(transPosStatus == KErrNone);
return TestStepResult();
}
void CT_LbsConflictStep_X3PPushMenu::NotifyMeasurementControlLocation(const TPositionInfo& aPosition,
const RLbsAssistanceDataBuilderSet& aData,
const TLbsNetPosRequestQuality& aQuality)
{
T_LbsUtils utils;
TInt err;
// Determine and record sequence event.
if (iState == EReqX3PMenu)
{
INFO_PRINTF1(_L("Got - X3P(MENU) MOLR - NetSim Notify Measurement Control Location - Event."));
SetCurrentSeqEvent(EX3P_MENU_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
}
else if(iState == EReqX3PPush)
{
INFO_PRINTF1(_L("Got - X3P(PUSH) MOLR - NetSim Notify Measurement Control Location - Event."));
SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
}
// Verify the reference position.
TPositionInfo verifyRefPosInfo;
verifyRefPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(verifyRefPosInfo, aPosition))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
// Verify the assistance data.
RLbsAssistanceDataBuilderSet& data = const_cast<RLbsAssistanceDataBuilderSet&>(aData);
RUEPositioningGpsReferenceTimeBuilder* refTimeBuilder = NULL;
data.GetDataBuilder(refTimeBuilder);
// Create a reader from the builder's data to allow us to verify the actual
// assistance data.
RUEPositioningGpsReferenceTimeReader refTimeReader;
TRAP(err, refTimeReader.OpenL());
if (err == KErrNone)
{
refTimeReader.DataBuffer() = refTimeBuilder->DataBuffer();
if (!utils.VerifySimpleAssistanceData(refTimeReader))
{
INFO_PRINTF1(_L("Failed test, assistance data incorrect."));
SetTestStepResult(EFail);
}
refTimeReader.Close();
}
else
{
INFO_PRINTF2(_L("Failed test, assistance data reader err %d."), err);
SetTestStepResult(EFail);
}
// TODO: Check if we can verify aQuality in any way.
(void)aQuality;
}
TVerdict CT_LbsX3PIntByMoLr::doTestStepL()
{
INFO_PRINTF1(_L("CT_LbsX3PIntByMoLr::doTestStepL()"));
// Stop the test if the preable failed
TESTL(TestStepResult() == EPass);
const TInt KTimeOut = 60*1000*1000;
// Create Network Protocol Proxy
CNetProtocolProxy* proxy = CNetProtocolProxy::NewL();
CleanupStack::PushL(proxy);
// >> AdviceSystemStatus(0) - GetCurrentCapabilitiesResponse
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgGetCurrentCapabilitiesResponse);
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt;
cleanupCnt = proxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// Start Test Step
RPositionServer server;
TESTL(KErrNone == server.Connect());
CleanupClosePushL(server);
RPositioner pos;
TESTL(KErrNone == pos.Open(server));
CleanupClosePushL(pos);
// Set the max fix time for the client request to ensure the location server does not complete the request too soon during the test.
TPositionUpdateOptions posOpts(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(240000000));
pos.SetUpdateOptions(posOpts);
CPosServerWatcher *pWatch = CPosServerWatcher::NewLC(pos, *this);
// Request a self-locate MoLr.
pWatch->IssueNotifyPositionUpdate();
// >> RequestSelfLocation()
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestSelfLocation);
// Process the response.
TLbsNetSessionId* sessionId = NULL;
TLbsNetPosRequestOptionsAssistance* opts = NULL;
cleanupCnt = proxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts);
iSessionId.SetSessionNum(sessionId->SessionNum());
iSessionId.SetSessionOwner(sessionId->SessionOwner());
CleanupStack::PopAndDestroy(cleanupCnt);
sessionId = NULL;
opts = NULL;
// << ProcessStatusUpdate(EServiceSelfLocation)
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceSelfLocation;
proxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask);
// << ProcessLocationUpdate(SessionId, RefPosition)
TPositionInfo refPosInfo = ArgUtils::MolrReferencePositionInfo();
proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
// TEST: Get the ref pos app side.
CheckForObserverEventTestsL(KTimeOut, *this);
// << ProcessAssistanceData()
TLbsAsistanceDataGroup dataMask = EAssistanceDataReferenceTime;
RLbsAssistanceDataBuilderSet assistanceData;
ArgUtils::PopulateLC(assistanceData);
TInt reason = KErrNone;
proxy->CallL(ENetMsgProcessAssistanceData, &dataMask, &assistanceData, &reason);
CleanupStack::PopAndDestroy(); // assistanceData
// << ProcessLocationRequest(SessionId, HybridMode, alpha2)
TBool emergency = EFalse;
MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
TLbsNetPosRequestQuality quality = ArgUtils::Quality();
quality.SetMaxFixTime(ArgUtils::Alpha2());
TLbsNetPosRequestMethod method = ArgUtils::RequestHybridMethod();
proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
// Now that the hybrid/alpha2 has been requested, record current time to verify alpha2 timer expires correctly.
TTime startTime;
startTime.HomeTime();
// >> RequestAssistanceData(0)
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// << NotifyPositionUpdate()
pWatch->IssueNotifyPositionUpdate();
// >> RequestAssistanceData(0)
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// Determine the value to take off the alpha2 value. This is required because we had to wait for the assistance data response.
TTimeIntervalMicroSeconds microseconds;
TTime stopTime;
stopTime.HomeTime();
microseconds = stopTime.MicroSecondsFrom(startTime);
TInt64 timeElapsed = microseconds.Int64();
TInt delta = 2 * 1000 * 1000; // 2 secs.
// >> RespondLocationRequest()
TESTL(proxy->WaitForResponse(ArgUtils::Alpha2() - timeElapsed - delta) == ENetMsgTimeoutExpired);
// Wait for and process the response.
TESTL(proxy->WaitForResponse(2 * delta) == ENetMsgRespondLocationRequest); // DONT get because the measurement data bus has not been created...
sessionId = NULL;
TPositionGpsMeasurementInfo* measurementInfo = NULL;
cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &measurementInfo);
TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
TESTL(reason == KErrNone);
CleanupStack::PopAndDestroy(cleanupCnt);//sessionId, measurementInfo
// Recv -> RequestAssistanceData - we get an extra msg as the result of the A-GPS manager re-issueing a location request when it's
// max fix time timer expries.
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
const TInt t = 8 * 1000 * 1000; // 8 secs.
quality.SetMaxFixTime(t);
TPositionInfo* positionInfo = NULL;
for (TInt i = 0; i < KN; i++)
{
// << ProcessLocationRequest(SessionId, HybridMode, t)
proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
// >> RequestAssistanceData(0)
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// >> RespondLocationRequest() - first measurement, second position.
TESTL(proxy->WaitForResponse(t + delta) == ENetMsgRespondLocationRequest);
sessionId = NULL;
// Expect measurement first time.
if (i < (KN-1))
{
measurementInfo = NULL;
cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &measurementInfo);
// Check it is measurement
TESTL(measurementInfo->PositionClassType() == EPositionGpsMeasurementInfoClass);
// >> RequestAssistanceData - we get an extra msg as the result of the A-GPS manager re-issueing a location request when it's
// max fix time timer expries.
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt += proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
TESTL(reason == KErrNone);
}
// Expect position second time.
else
{
cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo);
// check it is a position
TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass|EPositionExtendedSatelliteInfoClass));
TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
TESTL(reason == KErrNone);
// Client recv - the gps position determined by the gps module.
CheckForObserverEventTestsL(KTimeOut, *this);
TESTL(iState == EGpsLocReceived);
// << ProcessLocationUpdate(SessionId, FinalNetworkPosition)
// Return modules' position as FinalNetworkPosition
proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, positionInfo);
}
CleanupStack::PopAndDestroy(cleanupCnt);// sessionId, measurementInfo/positionInfo
}
// << ProcessSessionComplete(SessionId, KErrNone)
reason = KErrNone;
proxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
// << ENetMsgProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask serviceMask = MLbsNetworkProtocolObserver::EServiceNone;
proxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask);
// Done. Now cleanup...
CleanupStack::PopAndDestroy(pWatch);
CleanupStack::PopAndDestroy(); // pos
CleanupStack::PopAndDestroy(); // server
CleanupStack::PopAndDestroy(proxy);
return TestStepResult();
}
/**
* @return - TVerdict code
* Override of base class pure virtual
* Our implementation only gets called if the base class doTestStepPreambleL() did
* not leave. That being the case, the current test result value will be EPass.
*/
TVerdict CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL()
{
// Generic test step used to test the LBS Client Notify position update API.
INFO_PRINTF1(_L(">>CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL()"));
if (TestStepResult()==EPass)
{
iNetworkUnavailable = FALSE;
iIsCancelTest = FALSE;
iCancel = FALSE;
iCancelOnPosUpdate = FALSE;
iCancelBeforePosUpdate = FALSE;
iMultiReq = EFalse;
iNumNPUDs = iParent.iSharedData->iVerifyPosInfoArr.Count(); // how many NPUDs to do
// Expected callbacks flags
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_NetworkBasedLocation |
KLbsCallback_Got_NotifyPositionUpdate; // notifypositionupdate completed.
TTimeIntervalMicroSeconds32 abortInterval;
if(iParent.iSharedData->iTestModuleInUse)
{
abortInterval = KDefaultAbortTimerPeriod;
}
else
{
abortInterval = KDefaultAbortTimerPeriod_real;
}
// Carryout unique test actions.
TInt testCaseId;
if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))
{
switch (testCaseId)
{
case 1: // LBS-NotifyPosUpdateCellBased-0001 Request a cell-based location
{
// nothing to do
}
break;
case 2: // LBS-NotifyPosUpdateCellBased-0002 Request a cell-based location and cancel before it completes
{
iCancel = ETrue;
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_Got_NotifyPositionUpdate;
}
break;
case 3: // LBS-NotifyPosUpdateCellBased-0003 Request a cell-based location, when network unavailable
{
iNetworkUnavailable = ETrue;
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_NetSim_Got_NotifyRegisterLcsMoLr |
KLbsCallback_Got_NotifyPositionUpdate;
}
break;
case 4: // LBS-NotifyPosUpdateCellBased-0004 multiple sequential npuds
{
iMultiReq = ETrue;
}
break;
case 5: // LBS-NotifyPosUpdateCellBased-0005 Request a cell-based location and attempt to cancel when the update is received
{
iCallbackFlags = 0;
iCancelOnPosUpdate = ETrue;
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation |
KLbsCallback_Got_NotifyPositionUpdate;
}
break;
case 6: // LBS-NotifyPosUpdateCellBased-0006 Request a cell-based location and cancel before a position update is generated
{
iCancelBeforePosUpdate = ETrue;
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_Got_NotifyPositionUpdate;
}
break;
default:
User::Panic(KLbsClientStepCellBasedNotifyPosUpdate, KErrUnknown);
}
}
else
{
User::Panic(KLbsClientStepCellBasedNotifyPosUpdate, KErrUnknown);
}
iIsCancelTest = (iCancel || iCancelBeforePosUpdate || iCancelOnPosUpdate);
// Steps common to all tests:
// Connect to net sim
iNetSim.ConnectL(this);
// Configure NetSim:
// Set reference location:
RPointerArray<TAny>& srcPosInfoArr = iParent.iSharedData->iVerifyPosInfoArr;
TPositionInfo* srcPosInfo = reinterpret_cast<TPositionInfo*>(srcPosInfoArr[0]);
TPosition srcPos;
srcPosInfo->GetPosition(srcPos);
if (!iNetSim.SetReferenceLocation(srcPos))
{
INFO_PRINTF1(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL() Failed: Can't set NetSim's reference location."));
SetTestStepResult(EFail);
}
// Set plugin to use for getting assistance data:
TUid pluginUid;
if(iParent.iSharedData->iTestModuleInUse)
{
pluginUid = TUid::Uid(KSimpleAssistanceDataProviderPluginUidValue);
}
else
{
pluginUid = TUid::Uid(KSuplAssistanceDataProviderPluginUidValue);
}
if (!iNetSim.SetAssistanceDataProvider(pluginUid))
{
INFO_PRINTF1(_L("Can't set NetSim's assistance data plugin uid."));
SetTestStepResult(EFail);
}
// Kick off the keep alive timer - do last to ensure NetSim is ready otherwise the
// timer callback may start a MO-LR if the NetSim connected too early.
TTimeIntervalMicroSeconds32 interval(KLbsKeepAlivePeriod);
iKeepAliveTimer->SetTimer(interval);
// don't wait for TEF to timeout and abort
iAbortTimer->SetTimer(abortInterval);
// Kick off test.
CActiveScheduler::Start();
if(EDone != iState)
{
INFO_PRINTF2(_L("Failed test, finished in state %d"), iState);
INFO_PRINTF3(_L("Callback flags currently set = 0x%x. Expecting 0x%x"), iCallbackFlags, iFlagsToHaltOn);
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF2(_L("Got all expected callbacks (0x%x)"), iCallbackFlags);
}
iNetSim.Close();
}
INFO_PRINTF1(_L("<<CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL()"));
return TestStepResult();
}
TVerdict CT_LbsPTAMOLRPartialEarlyComplete::doTestStepL()
{
INFO_PRINTF1(_L("CT_LbsPTAMOLRPartialEarlyComplete::doTestStepL()"));
// Stop the test if the preable failed
TESTL(TestStepResult() == EPass);
const TInt KTimeOut = 60*1000*1000;
// Create Network Protocol Proxy
CNetProtocolProxy* proxy = CNetProtocolProxy::NewL();
CleanupStack::PushL(proxy);
// >> AdviceSystemStatus(0) - GetCurrentCapabilitiesResponse
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgGetCurrentCapabilitiesResponse);
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt;
cleanupCnt = proxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// Start Actual Test Step
RPositionServer server;
TESTL(KErrNone == server.Connect());
CleanupClosePushL(server);
RPositioner pos;
TESTL(KErrNone == pos.Open(server));
CleanupClosePushL(pos);
// Set the max fix time for the client request to ensure the location server does not complete the request too soon during the test.
TPositionUpdateOptions posOpts(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(KMOLRFixTime), 0 , ETrue);
pos.SetUpdateOptions(posOpts);
CPosServerWatcher *pWatch = CPosServerWatcher::NewLC(pos, *this);
// Client Send: Request a self-locate MoLr.
pWatch->IssueNotifyPositionUpdate();
//Recv: RequestSelfLocation()
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestSelfLocation);
// Process the response.
TLbsNetSessionId* sessionId = NULL;
TLbsNetPosRequestOptionsAssistance* opts = NULL;
cleanupCnt = proxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts);
TBool qualitycheck = ArgUtils::CompareQuality( opts,
ETrue,
KMinHorizontalAcc, /* as read from quality profile on z: */
KMinVerticalAcc,
KMOLRFixTime,
0,
EAssistanceDataReferenceTime,
(TPositionModuleInfo::ETechnologyNetwork
| TPositionModuleInfo::ETechnologyAssisted)
);
TESTL(qualitycheck);
iSessionId.SetSessionNum(sessionId->SessionNum());
iSessionId.SetSessionOwner(sessionId->SessionOwner());
CleanupStack::PopAndDestroy(cleanupCnt);
//Send: ProcessStatusUpdate(EServiceSelfLocation)
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceSelfLocation;
proxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask);
// Client Recv: (KPositionPartialUpdate, GPS Info)
// in TAP mode dont get any AGPS psotions! CheckForObserverEventTestsL(KTimeOut, *this);
// TESTL(iState == EGpsPartialInitReceived);
//Client Send: Notify Position Update
// pWatch->IssueNotifyPositionUpdate();
//Recv: RequestAssistanceData(Mask=0) - as result of the second client noitfy update request.
TLbsAsistanceDataGroup dataMask;
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
//Client Send: CompleteRequest
TESTL(pos.CompleteRequest(EPositionerNotifyPositionUpdate) == KErrNone);
// Client Recv: Second Partial update position - This should return with KPositionEarlyComplete
CheckForObserverEventTestsL(KTimeOut, *this);
TESTL(iState == EGpsPartialEarlyReceived);
//Send: ProcessLocationUpdate(SessionId, RefPosition)
TPositionInfo refPosInfo = ArgUtils::MolrReferencePositionInfo();
proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
//Send: ProcessAssistanceData()
dataMask = EAssistanceDataReferenceTime;
RLbsAssistanceDataBuilderSet assistanceData;
ArgUtils::PopulateLC(assistanceData);
TInt reason = KErrNone;
proxy->CallL(ENetMsgProcessAssistanceData, &dataMask, &assistanceData, &reason);
CleanupStack::PopAndDestroy();
//Send: ProcessLocationRequest(SessionId, HybridMode, alpha2)
TBool emergency = EFalse;
MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
TLbsNetPosRequestQuality quality = ArgUtils::Quality();
quality.SetMaxFixTime(ArgUtils::Alpha2());
TLbsNetPosRequestMethod method = ArgUtils::RequestHybridMethod();
proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
//Recv: RequestAssistanceData(Mask=0)
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
//Recv: Wait for and process the response (SessionId=1, KErrNone, GpsPos2)
TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRespondLocationRequest);
TPositionInfo* positionInfo = NULL;
sessionId = NULL;
cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo);
TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass));
TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
TESTL(reason == KErrNone);
CleanupStack::PopAndDestroy(cleanupCnt);
//Send: ProcessLocationUpdate(SessionId, FinalNetworkPosition)
TPositionInfo networkPosInfo = ArgUtils::MolrNetworkPositionInfo();
proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &networkPosInfo);
//Send: ProcessSessionComplete(SessionId, KErrNone)
reason = KErrNone;
proxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
//Send: ENetMsgProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask serviceMask = MLbsNetworkProtocolObserver::EServiceNone;
proxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask);
// Wait for 10 seconds to ensure no additional responses turn up.
TInt delta = 10 * 1000 * 1000;
TNetProtocolResponseType mType = proxy->WaitForResponse(delta);
TESTL(mType == ENetMsgTimeoutExpired);
//Done. Now cleanup...
CleanupStack::PopAndDestroy(pWatch);
CleanupStack::PopAndDestroy(); // pos
CleanupStack::PopAndDestroy(); // server
CleanupStack::PopAndDestroy(proxy);
return TestStepResult();
}
/** Perform Cmtlr5Step test step.
This test checks that the Protocol Module handles the case in which LBS requests further
assistance data.
2 data items are requested - one is included in the rrlp assistance data message, and one
is included in the rrlp measure position request.
@return TVerdict test result code
*/
TVerdict Cmtlr5Step::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tMTLR basic procedure - not all requested assistance data delivered..."));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate MT-LR
// Generate received SUPL INIT message (test message content #0)
TPtr8 messagePtr(iReceiveBuffer.Des());
TInt err = iSuplInitGenerator->GenerateSuplInitL(0, messagePtr);
if (err != KErrNone)
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Inject SUPL INIT using the SUPL Push API
INFO_PRINTF1(_L("\tLBS (SuplPush) -> OnSuplInit()"));
TLbsSuplPushRequestId reqId = 12345;
TPtrC8 message(messagePtr);
iSuplPush->SuplInit(reqId, message, 0);
// Check Gateway receives a Privacy request and Location Request
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest()"));
if (EFail == CheckGatewayCallbackL(CSuplGatewayObserver::EProcessLocationRequest) ||
!iGatewayObserver->IsPrivReqReceived() ||
MLbsNetworkProtocolObserver::EServiceMobileTerminated != iGatewayObserver->LocType() )
{
SetTestStepResult(EFail);
return TestStepResult();
}
// LBS delivers privacy response
INFO_PRINTF1(_L("\tLBS -> RespondPrivacyRequest ()"));
CLbsNetworkProtocolBase::TLbsPrivacyResponse privacyResponse = CLbsNetworkProtocolBase::EPrivacyResponseAccepted;
iModule->RespondPrivacyRequest(iGatewayObserver->SessionIdValue(), privacyResponse, 0);
// Check Connection Manager receives a request for connecting
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::EConnectReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t ConnectionRequest -> NET"));
// Simulate the connection is up (inject that event)
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t Connected <- NET"));
iNetworkObserver->InjectConnectedIndication(iNetworkObserver->SessionId());
// LBS Requests assistance data
INFO_PRINTF1(_L("\tLBS -> RequestAssistanceData ()"));
// Request both sets of assitance data.
// They'll be delivered in different SUPL POS messages later on in the test.
TLbsAsistanceDataGroup dataRequestMask1 = EAssistanceDataBadSatList;
TLbsAsistanceDataGroup dataRequestMask2 = EAssistanceDataIonosphericModel;
TLbsAsistanceDataGroup dataRequestMask = dataRequestMask1|dataRequestMask2;
TLbsNetSessionIdArray dummyIdArray;
iModule->RequestAssistanceData(dataRequestMask, dummyIdArray);
// Check Connection Manager receives a request to send a SUPL POS INIT
// with the assistance data mask requested by the gateway
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosInitSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS INIT -> NET"));
// Inject a SUPL POS with some of the Assistance data requested
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Assitance Data <- NET"));
CSuplMessageBase* suplPos = BuildSuplPosAssitDataL(dataRequestMask1, EFalse);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplPos);
// Check gateway receives the assistance data types requested.
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData()"));
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessAssistanceData) ||
(dataRequestMask1 & iGatewayObserver->AssistanceDataSetMask() != dataRequestMask1))
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Check the Connection Manager receives a request to send a SUPL POS (ack to assistance data)
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Assistance Data Ack -> NET"));
// Inject a SUPL POS (RRLP Measure Position Request) - does not contains missing assistance data
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Measure Position Request <- NET"));
suplPos = BuildSuplPosRequestL(TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted, dataRequestMask2);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplPos);
// Check gateway receives the assistance data types requested.
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData()"));
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessAssistanceData) ||
(dataRequestMask2 & iGatewayObserver->AssistanceDataSetMask() != dataRequestMask2))
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Check gateway receives a location request (due to the RRLP Measure Position Request)
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest()"));
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessLocationRequest) ||
MLbsNetworkProtocolObserver::EServiceMobileTerminated != iGatewayObserver->LocType())
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Fake LBS sending results (position) to SPM
INFO_PRINTF1(_L("\tLBS -> RespondLocationRequest"));
TReal64 latitude = 10;
TReal64 longitude = 0;
TReal32 HorAccuracy = 10;
TPositionInfo mobilePosInfo;
TTime utcTime;
utcTime.UniversalTime();
TCoordinate coor(latitude,longitude);
TPosition mobilePos(TLocality(coor,HorAccuracy),utcTime);
mobilePosInfo.SetPosition(mobilePos);
iModule->RespondLocationRequest(iGatewayObserver->SessionIdValue(),KErrNone,mobilePosInfo);
// Check the Connection Manager receives a request to send a SUPL POS (RRLP Measure Position Response)
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Measure Position Response -> NET"));
// Inject a SUPL END (without position)
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL END <- NET"));
CSuplMessageBase* suplEnd = BuildSuplEndL(EFalse);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplEnd);
// Check gateway session completed
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessSessionComplete))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete"));
// Check Connection Manager receives a disconnection request
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::EDisconnectReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t DisconnectRequest -> NET"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
void CT_LbsConflictStep_selflocatex3ppush::NotifyMeasurementControlLocation(const TPositionInfo& aPosition,
const RLbsAssistanceDataBuilderSet& aData,
const TLbsNetPosRequestQuality& aQuality)
{
T_LbsUtils utils;
TInt err;
// Determine and record sequence event.
if (iState == EReqPosUpdate)
{
INFO_PRINTF1(_L("Got - Self MOLR - NetSim Notify Measurement Control Location - Event."));
// cannot record this event since it may/maynot occur depending on timing but ...
// SetCurrentSeqEvent(ESelf_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
// ... if we do get one of these, we must get a failure message so add that to adhoc list
SetVerifyAdhocEvent(ESelf_MOLR_NetSim_Got_NotifyMeasurementReportControlFailure);
}
else if(iState == EReqX3P)
{
INFO_PRINTF1(_L("Got - X3P MOLR - NetSim Notify Measurement Control Location - Event."));
SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
}
// Verify the reference position.
TPositionInfo verifyRefPosInfo;
verifyRefPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(verifyRefPosInfo, aPosition))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
// Verify the assistance data.
RLbsAssistanceDataBuilderSet& data = const_cast<RLbsAssistanceDataBuilderSet&>(aData);
RUEPositioningGpsReferenceTimeBuilder* refTimeBuilder = NULL;
data.GetDataBuilder(refTimeBuilder);
// Create a reader from the builder's data to allow us to verify the actual
// assistance data.
RUEPositioningGpsReferenceTimeReader refTimeReader;
TRAP(err, refTimeReader.OpenL());
if (err == KErrNone)
{
refTimeReader.DataBuffer() = refTimeBuilder->DataBuffer();
if (!utils.VerifySimpleAssistanceData(refTimeReader))
{
INFO_PRINTF1(_L("Failed test, assistance data incorrect."));
SetTestStepResult(EFail);
}
refTimeReader.Close();
}
else
{
INFO_PRINTF2(_L("Failed test, assistance data reader err %d."), err);
SetTestStepResult(EFail);
}
// TODO: Check if we can verify aQuality in any way.
(void)aQuality;
}
// ---------------------------------------------------------
// CT_LbsClientPosTp1::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp1::StartL()
{
ConnectL();
CPosModules* db = CPosModules::OpenL();
CleanupStack::PushL(db);
SetupPsyL(iUidMultiPsy);
_LIT(KSetupPSY, "TP1: Has Setup Multi PSY");
INFO_PRINTF1(KSetupPSY);
//setting priority
TPositionModuleInfo moduleInfoHp;//Hp - high prio;
TPositionModuleInfo moduleInfoLp;//Lp - low prio;
CPosModuleIdList* prioList = db->ModuleIdListLC();
db->GetModuleInfoL(prioList->At(0), moduleInfoHp);
CPosModuleUpdate* moduleUpdate = CPosModuleUpdate::NewLC();
moduleUpdate->SetUpdateAvailability(ETrue);
if (iUidMultiPsy.iUid == moduleInfoHp.ModuleId().iUid)
{
// Case when Multi PSY has highest prio:
// Ensuring it is enabled
_LIT(KMultiHighest, "TP1: Case when Multi PSY has highest prio");
INFO_PRINTF1(KMultiHighest);
db->UpdateModuleL((*prioList)[0], *moduleUpdate);
}
else
{
// Case when Multi PSY has not highest prio:
//
_LIT(KMultiNotHighest, "TP1: Case when Multi PSY has NOT highest prio");
INFO_PRINTF1(KMultiNotHighest);
db->GetModuleInfoL(iUidMultiPsy, moduleInfoLp);
// Ensuring it is enabled
db->UpdateModuleL(iUidMultiPsy, *moduleUpdate);
TUint hp = db->PriorityL(moduleInfoHp.ModuleId());
TUint lp = db->PriorityL(moduleInfoLp.ModuleId());
// Changing prio of highest prio PSY and Multi PSY.
// Setting Multi PSY to highest prio
db->SetModulePriorityL(iUidMultiPsy, hp);
db->SetModulePriorityL((*prioList)[0], lp);
}
_LIT(KTestPSY1On, "TP1: Enabling Test PSY 1");
INFO_PRINTF1(KTestPSY1On);
db -> UpdateModuleL(iUidTestPsy1, *moduleUpdate);
_LIT(KTestPSY2On, "TP1: Enabling Test PSY 2");
INFO_PRINTF1(KTestPSY2On);
db -> UpdateModuleL(iUidTestPsy2, *moduleUpdate);
CleanupStack::PopAndDestroy(moduleUpdate);
CleanupStack::PopAndDestroy(2, db); // db, prioList
User::LeaveIfError(OpenPositioner());
// Request data from default psy should be Multi psy
_LIT(KService, "service");
TPositionInfo posInfo = TPositionInfo();
TInt err = PerformSyncRequest(KService, &posInfo);
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrNone");
LogErrorAndLeaveL(KErrorRequest, err);
}
if (iUidMultiPsy.iUid != posInfo.ModuleId().iUid)
{
_LIT(KIncorrectPsyError, "TP1. Position from wrong PSY received");
LogErrorAndLeaveL(KIncorrectPsyError);
}
HPositionGenericInfo* genericInfo = HPositionGenericInfo::NewLC();
err = PerformSyncRequest(KService, &(*genericInfo));
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrNone");
LogErrorAndLeaveL(KErrorRequest);
}
if (iUidMultiPsy.iUid != (genericInfo -> ModuleId()).iUid)
{
_LIT(KIncorrectPsyError,
"TP1. Position from wrong PSY received");
LogErrorAndLeaveL(KIncorrectPsyError);
}
TPositionCourseInfo courseInfo = TPositionCourseInfo();
err = PerformSyncRequest(KService, &courseInfo);
if (err != KErrNone)
{
_LIT(KErrorRequest, "Course info supported by default, but request failed");
LogErrorAndLeaveL(KErrorRequest);
}
TPositionSatelliteInfo satelliteInfo = TPositionSatelliteInfo();
err = PerformSyncRequest(KService, &satelliteInfo);
if (err != KErrNone)
{
_LIT(KErrorRequest, "Satellite info supported by default, but request failed");
LogErrorAndLeaveL(KErrorRequest);
}
//Changing the priority and verifiy that it still possilbe
//to request updated from a psy if basic position information
//is used and that it is not possilbe to request sat or cource
//any more.
SetupPsyL(iUidTestPsy2);
User::After(3000000);
// Request data from default psy should be test psy 2 now
err = PerformSyncRequest(KService, &posInfo);
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrNone");
LogErrorAndLeaveL(KErrorRequest);
}
if (iUidTestPsy2.iUid != posInfo.ModuleId().iUid)
{
_LIT(KIncorrectPsyError,
"TP1. Position from wrong PSY received");
LogErrorAndLeaveL(KIncorrectPsyError);
}
err = PerformSyncRequest(KService, &(*genericInfo));
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrNone");
LogErrorAndLeaveL(KErrorRequest);
}
if (iUidTestPsy2.iUid != (genericInfo -> ModuleId()).iUid)
{
_LIT(KIncorrectPsyError,
"TP1. Position from wrong PSY received");
LogErrorAndLeaveL(KIncorrectPsyError);
}
err = PerformSyncRequest(KService, &courseInfo);
if (err != KErrArgument)
{
_LIT(KErrorRequest, "Course info not supported by default, KErrArgument not returned");
LogErrorAndLeaveL(KErrorRequest);
}
err = PerformSyncRequest(KService, &satelliteInfo);
if (err != KErrArgument)
{
_LIT(KErrorRequest, "Satellite info not supported by default, KErrArgument not returned");
LogErrorAndLeaveL(KErrorRequest);
}
//check that it is possilbe to change the different
//type of class info during periodic request and
//that the periodic update will fail if the class
//type is incorrect.
TTimeIntervalMicroSeconds interval = TTimeIntervalMicroSeconds(1000000);
TPositionUpdateOptions posOption;
posOption.SetUpdateInterval(interval);
_LIT(KUpdateErr, "Error when setting update interval, %d");
err = iPositioner.SetUpdateOptions(posOption);
AssertTrueL(err == KErrNone, KUpdateErr, err);
_LIT(KErrPeriodic, "The periodic request did not return KErrNone, %d");
err = PerformSyncRequest(KService, &posInfo);
AssertTrueL(err == KErrNone , KErrPeriodic, err);
_LIT(KErrPeriodicArr, "The periodic request did not return KErrArgument, %d");
err = PerformSyncRequest(KService, &satelliteInfo);
AssertTrueL(err == KErrArgument , KErrPeriodicArr, err);
SetupPsyL(iUidMultiPsy);
User::After(3000000);
err = PerformSyncRequest(KService, &satelliteInfo);
AssertTrueL(err == KErrNone , KErrPeriodic, err);
CleanupStack::PopAndDestroy(genericInfo);
ClosePositioner();
Disconnect();
}
