void CPositionRequest::StartPositionDataRequestPhase()
{
LBS_RDEBUG_VAR_INT("CPositionRequest::StartPositionDataRequestPhase() iRequestPhase", iRequestPhase);
__ASSERT_DEBUG(iPositioner,
DebugPanic(EPosServerPanicPositionerNotInitialized));
iReqStartTime.UniversalTime();
TPositionInfo& info = PositionInfo(iPositionBuffer);
// Set datum type to WGS84
TPosition position;
info.GetPosition(position);
position.SetDatum(KPositionDatumWgs84);
info.SetPosition(position);
TPositionInfoBase& infoBase = reinterpret_cast<TPositionInfoBase&>(info);
// issue request to psy
DEBUG_TRACE("calling CPositioner::NotifyPositionUpdate()", __LINE__)
iStatus = KRequestPending;
iPositioner->NotifyPositionUpdate(infoBase, iStatus);
iRequestPhase = EPosReqPositionRequest;
SetActive();
}
void CPosition::RunL()
{
TPosition position;
iPositionInfo.GetPosition(position);
TTime now;
now.UniversalTime();
TTimeIntervalSeconds interval = 0;
now.SecondsFrom(position.Time(), interval);
LOGARG("Interval between retrieved position and current time: %d secs", interval.Int());
// Compare that retrieved data is not outdated
if (iStatus == KErrNone && interval.Int() < 300)
{
iObserver.PositionUpdateL(iStatus.Int(), position);
}
else if (iStatus == KErrTimedOut)
{
iObserver.PositionUpdateL(iStatus.Int(), position);
}
else
{
iPositioner.NotifyPositionUpdate(iPositionInfo, iStatus);
SetActive();
iState = EGps;
}
}
// ---------------------------------------------------------
// 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);
}
/** Calculates a difference between the system UTC time and the GPS based UTC time.
Accuracy of the calculations is affected by:
- time required to process the satellite information in the GPS HW
- time required to transfer the information over a HW link from the GPS HW to a mobile phone
- time required to receive the information by a Symbian OS drivers and decode by the AGPS
integration module
@param aSatInfo A satellite information with the GPS based UTC time
@param aTimeCorr A time correction that must be applied to the System UTC time. Not valid if the method returns an error.
@return KErrNone if sucedded.
KErrNotSupported if the satellite (GPS based UTC time) or the position
reception time is not present (0).
@see TPositionSatelliteInfo
@internalComponent
*/
TInt CAutoClockAdjust::CalculateTimeCorrection(const TPositionSatelliteInfo &aSatInfo, TTimeIntervalMicroSeconds &aTimeCorr)
{
LBSLOG(ELogP1, "CAutoClockAdjust::CalculateTimeCorrection()\n");
// The System UTC time when the location has been received from a GPS
TTime recTime;
// GPS based UTC time (satellite time)
TTime satTime;
TPosition pos;
TInt err = KErrNone;
aSatInfo.GetPosition(pos);
recTime = pos.Time();
satTime = aSatInfo.SatelliteTime();
if ((recTime == 0) || (satTime == 0))
{
err = KErrNotSupported;
}
else
{
aTimeCorr = satTime.MicroSecondsFrom(recTime);
}
return err;
}
//
// 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();
}
/** Adjusts system time if required. The decision whether the adjustment is needed or not
is based on the following criterias:
- satellite time must be present in the location update
- time threshold must be exceeded
- time from a last adjustment is greater than a defined interval.
@param aStatus An error code.
@param TPositionSatelliteInfo Position and time information.
If clock adjustment takes place the TPosition::iTime is
re-set to the satellite time.
@see CLbsAdmin
@see TPositionSatelliteInfo
*/
void CAutoClockAdjust::LocationUpdate(TInt aStatus, TPositionSatelliteInfo& aPosInfo)
{
LBSLOG(ELogP1, "CAutoClockAdjust::LocationUpdate()\n");
TTimeIntervalMicroSeconds timeCorr;
TTime sysTime;
TInt err;
// If adjustment on, no error, and satellite information present
if ((iClockAdjustSetting == CLbsAdmin::EClockAdjustOn) && (aStatus == KErrNone) &&
((aPosInfo.PositionClassType() & EPositionSatelliteInfoClass) == EPositionSatelliteInfoClass))
{
// Is is time do do another time adjustment?
sysTime.UniversalTime();
if (Abs(sysTime.MicroSecondsFrom(iLastAdjustment).Int64()) > (1000*iAdjustInterval))
{
const TPositionSatelliteInfo& satInfo = static_cast<const TPositionSatelliteInfo&>(aPosInfo);
err = CalculateTimeCorrection(satInfo, timeCorr);
if (err == KErrNone)
{
// Is threshold exceeded?
if (Abs(timeCorr.Int64()) > (1000*iAdjustThreshold))
{
sysTime.UniversalTime();
sysTime += timeCorr;
LBSLOG(ELogP9, "->S CGpsSetClockBase::SetUTCTime() ClockModule\n");
LBSLOG5(ELogP9, " > TTime sysTime = %02d:%02d:%02d.%06d\n", sysTime.DateTime().Hour(),
sysTime.DateTime().Minute(),
sysTime.DateTime().Second(),
sysTime.DateTime().MicroSecond());
err = iSetClockImpl->SetUTCTime(sysTime);
LBSLOG2(ELogP9, " Return = %d\n", err);
if (err == KErrNone)
{
// Sync the position time with the satellite time
// to avoid re-adjusting the system time by the manual clock adjustment component.
TPosition pos;
aPosInfo.GetPosition(pos);
pos.SetTime(aPosInfo.SatelliteTime());
aPosInfo.SetPosition(pos);
LBSLOG2(ELogP2, "ACTION: Clock Adjusted by %ld\n", timeCorr.Int64());
}
}
if (err == KErrNone)
{
// Remember the current time even if threshold not exceeded
iLastAdjustment = sysTime;
}
else
{
LBSLOG_WARN2(ELogP3, "Clock Adjustment failed. Error: %d\n", err);
}
}
}
}
}
void CTe_LbsLocationMonitorSuiteStepBase::ComparePositions(TPosition& aLeft, TPosition& aRight)
{
TEST(aLeft.HorizontalAccuracy() == aRight.HorizontalAccuracy());
TEST(aLeft.VerticalAccuracy() == aRight.VerticalAccuracy());
TEST(aLeft.Latitude() == aRight.Latitude());
TEST(aLeft.Longitude() == aRight.Longitude());
TEST(aLeft.Altitude() == aRight.Altitude());
}
/*
This method returns a position to the client. In some testcases, the completion of the
asynchronous request may be delayed.
*/
TInt RLbsLocMonitorDb::GetLastStoredPosition(TPosition& aPosition, TRequestStatus& aStatus)
{
LBSLOG(ELogP1, "RLbsLocMonitorDb::GetLastStoredPosition()");
TInt completionCode = KErrNone;
aStatus = KRequestPending;
iCallCount ++;
if (iFailNextRequest)
{
completionCode = KErrNotFound;
iFailNextRequest = EFalse;
}
else if(iShortDelayNextRequest || iLongDelayNextRequest)
{
// Remember client request's return parms and
// force a delay.
iClientPosition = &aPosition;
iClientStatus = &aStatus;
if (!iTimer->IsActive())
{
TInt delayInMicroSecs = iLongDelayNextRequest?15000000:1000000; // 15 or 1 second
iTimer->Start(delayInMicroSecs, delayInMicroSecs, TCallBack(StopWaiting, this));
}
else
{
// A delay has already been applied. Nothing to do.
}
iShortDelayNextRequest = EFalse;
iLongDelayNextRequest = EFalse;
return KErrNone;
}
else
{
switch (iCallCount)
{
case 1:
// Set a position as if it came from the DB
aPosition.SetCoordinate(KLatGetLast1, KLongGetLast1);
break;
// Return different values for second and later requests
// that occurred in the same test.
default:
aPosition.SetCoordinate(KLatGetLast2, KLongGetLast2);
break;
}
}
TRequestStatus* status = &aStatus;
User::RequestComplete(status, completionCode);
return KErrNone;
}
void CPositionRequest::SaveAsLastKnownPosition()
{
TPosition pos;
TPositionInfo& positionInfo = PositionInfo(iPositionBuffer);
positionInfo.GetPosition(pos);
// Don't set last known position if the position request is in the past. //TODO check if this is required
if (iReqStartTime <= pos.Time())
{
iLocMonitorReqHandler.SetPositionInfo(positionInfo);
}
}
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);
}
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();
}
EXPORT_C void RLbsLocMonitorAreaPositioner::GetLastKnownPosition(TPositionInfoBase& aPosInfo,
TRequestStatus& aStatus) const
{
const_cast<RLbsLocMonitorAreaPositioner*>(this)->SetLKPosRequestStatus(&aStatus);
aStatus = KRequestPending;
TPositionInfo& posinfo = reinterpret_cast<TPositionInfo &>(aPosInfo);
TReal64 testlatitude,testlongitude, testaltitude;
testlatitude = 51.88; testlongitude = 0.45; testaltitude = 0.0;
TPosition testpos;
testpos.SetCoordinate(DUMMY_LAST_KNOWN_POS_LATITUDE1, DUMMY_LAST_KNOWN_POS_LONGITUDE1, DUMMY_LAST_KNOWN_POS_ALTITUDE1);
posinfo.SetPosition(testpos);
// as CPeriodic class is used, a higher value of interval ensures we do not receive
// multiple callbacks [we would like to complete the timer after the first callback].
TTimeIntervalMicroSeconds32 delay, interval;
delay = 2000000; //2 sec
interval = 100000000;
// Modify the behaviour of the Location Monitor based on the testcase using the value of the
// property
TInt testcase, propRead;
propRead = iTestLKPosKey.Get(KLocSrvTestSuite, KLbsLocMonitorTestLKPosKey,testcase);
if (propRead==KErrNone)
{
switch(testcase)
{
case EGetLKPosNotFound:
{
TRequestStatus* pStat = &aStatus;
User::RequestComplete(pStat, KErrNotFound);
return;
}
case EGetLKPosTimedOut:
delay = 1000000000;;
break;
default:
break;
}
}
iDelayedLKPosUpdate->Start(delay, interval, TCallBack(LKPosTimerCallback, const_cast<RLbsLocMonitorAreaPositioner*>(this)));
}
void CTriggerFireObserver::CheckPositionInfoL( const TLbtTriggerFireInfo& aFireInfo )
{
TPositionInfo posInfo= aFireInfo.iFiredPositionInfo;
TPosition pos;
posInfo.GetPosition(pos);
TCoordinate firedinfo( pos.Latitude(),pos.Longitude());
TReal32 distance;
firedinfo.Distance( iCoordinate,distance);
if( distance<=iRadiusInMetres )
{
User::Leave(KErrGeneral);
}
}
// ---------------------------------------------------------
// CTestPsy4Positioner::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsTestProxyPsy5Positioner::NotifyPositionUpdate(TPositionInfoBase& aPosInfo, TRequestStatus& aStatus)
{
TPositionInfo* posInfo = static_cast<TPositionInfo*> (&aPosInfo);
TPosition pos;
pos.SetCoordinate(99, 99, 99);
posInfo->SetPosition(pos);
TUint32 request = posInfo->UpdateType();
switch (request)
{
case 304:
iRequestHandler->SetErrorCode(KErrNone);
break;
default:
iRequestHandler->SetErrorCode(KErrUnknown);
break;
}
iRequestHandler->NotifyPositionUpdate(posInfo, &aStatus);
}
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 T_LbsUtils::GetConfigured_PosInfosL(const TDesC& aConfigFileName, const TDesC& aConfigSection, RPointerArray<TAny>& aPosInfoArr)
/** Fills a position info array with values read from a configuration ini file.
@param aConfigFileName The name of the ini file to read. If the file name is empty (0 length) then
the array will contain a single pos info item with default values.
@param aConfigSection The section within the ini file to read data from.
@param aPosInfoArr The pos info array to which the items are added. The array will cleared of
existing items.
*/
{
// Clear array.
ResetAndDestroy_PosInfoArr(aPosInfoArr);
// Check for config file, if not present create a single default TPositionInfo.
if (aConfigFileName.Length() == 0)
{
TPositionSatelliteInfo* posInfo = new(ELeave) TPositionSatelliteInfo();
TPosition position;
position.SetCoordinate(DEFAULT_NOTIFY_POS_UPDATE_LATITUDE, DEFAULT_NOTIFY_POS_UPDATE_LONGITUDE, DEFAULT_NOTIFY_POS_UPDATE_ALTITUDE);
position.SetAccuracy(DEFAULT_NOTIFY_POS_UPDATE_HORIZONTAL_ACCURACY, DEFAULT_NOTIFY_POS_UPDATE_VERTICAL_ACCURACY);
position.SetCurrentTime();
posInfo->SetPosition(position);
User::LeaveIfError(aPosInfoArr.Append(posInfo));
}
else
{
CPosInfoConfigReader* reader;
reader = CPosInfoConfigReader::NewL(aConfigFileName, aConfigSection, aPosInfoArr);
CleanupStack::PushL(reader);
reader->ProcessL();
CleanupStack::PopAndDestroy(reader);
}
}
TBool CGpsPositionRequest::FetchCurrentPostionL(TReal& aLatitude, TReal& aLongitude)
{
// cancel previous request (just in case)
Cancel();
// request current location
iPositioner.NotifyPositionUpdate(iPositionInfo, iStatus);
SetActive();
// start wait note and wait for request end
//ShowWaitNoteL();
// process result
if (iError == KErrNone)
{
// success, return given position
TPosition pos;
iPositionInfo.GetPosition(pos);
aLatitude = pos.Latitude();
aLongitude = pos.Longitude();
return ETrue;
}
// fail
return EFalse;
}
TInt CPositionRequest::PackPositionData()
{
TPositionInfo& info = PositionInfo(iPositionBuffer);
// Verify that ModuleId, set by PSY, is correct if using specific PSY.
// If a proxy PSY is used, the proxy is responsible for verifying UID.
if (!iHasProxyPositioner &&
info.ModuleId() != iPositionerParams.iImplementationUid)
{
return KErrGeneral;
}
// Check that datum type still is WGS84
TPosition position;
info.GetPosition(position);
if (position.Datum() != KPositionDatumWgs84)
{
return KErrNotSupported;
}
TPtr8 ptrToBuffer = iPositionBuffer->Des();
return Global::Write(iMessage, KParamPositionInfo, ptrToBuffer);
}
/**
* 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;
}
/** 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 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());
}
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_LbsClientPosTp2::CheckPositionL(TPosition& aPos)
{
if (aPos.Time() != TTime(KPositionTime) ||
aPos.HorizontalAccuracy() != KHorizontalAcc ||
aPos.VerticalAccuracy() != KVerticalAcc ||
aPos.Latitude() != KLatitude ||
aPos.Longitude() != KLongitude ||
aPos.Altitude() != KAltitude)
{
_LIT(KErrPosition, "Wrong position returned");
LogErrorAndLeaveL(KErrPosition);
}
}
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);)
/** Perform CNiLrStep1 test step.
This test verifies that the Test Protocol Module correctly handles
a Network Induced location request.
@return TVerdict test result code
*/
TVerdict CNiLrStep1::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tNILR basic procedure"));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate NI-LR
INFO_PRINTF1(_L("\t ProcessMeasurementControlLocation <- NET"));
TPositionInfo refLoc;
TPosition refPos;
refPos.SetHorizontalAccuracy(KRefPosHorizAcc);
refLoc.SetPosition(refPos);
RLbsAssistanceDataBuilderSet assistData;
CleanupClosePushL(assistData);
assistData.OpenL();
SetDummyAssistanceData(assistData, EAssistanceDataReferenceTime);
TLbsNetPosRequestQuality quality;
quality.SetMinHorizontalAccuracy(KLocReqHorizAcc);
iNetworkObserver->ProcessMeasurementControlLocationL(refLoc, assistData, quality);
CleanupStack::PopAndDestroy(&assistData);
// Check gateway receives Assistance data
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessAssistanceData) ||
EAssistanceDataReferenceTime != iGatewayObserver->AssistanceDataSetMask())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData"));
// Check gateway receives Network Based location
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationUpdate) ||
KRefPosHorizAcc != iGatewayObserver->ReferencePos().HorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationUpdate"));
// Check gateway receives Location Request
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationRequest) ||
iGatewayObserver->IsLocEmergency() ||
MLbsNetworkProtocolObserver::EServiceNetworkInduced != iGatewayObserver->LocType() ||
KLocReqHorizAcc != iGatewayObserver->LocQuality().MinHorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest"));
// Generate Location Response
INFO_PRINTF1(_L("\tLBS -> RespondLocationRequest"));
TInt reason = KErrNone;
TPositionInfo mobilePosInfo;
TPosition mobilePos;
mobilePos.SetHorizontalAccuracy(KMobilePosHorizAcc);
mobilePosInfo.SetPosition(mobilePos);
iModule->RespondLocationRequest(iGatewayObserver->SessionIdValue(),
reason, mobilePosInfo);
// Check network receives Location Response
if (EFail == CheckNetworkCallbackL(
CNetworkObserver::EMeasurementReportLocation) ||
KMobilePosHorizAcc != iNetworkObserver->MobilePos().HorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t MeasurementReportLocation -> NET"));
// Check gateway session completed
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessSessionComplete))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
// ---------------------------------------------------------
// CPosPSYClearPositionDataTest::CheckPositionClearsL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosPSYClearPositionDataTest::CheckPositionClearsL(
const TDesC& aPositionType)
{
TPosition position;
iPosInfo->GetPosition(position);
TBool allIsCleared = ETrue;
if (position.Time() == KTime)
{
_LIT(KError, "Time not cleared for ");
AddMessageL(KError, aPositionType, EErrorMessage);
allIsCleared = EFalse;
}
if (!Math::IsNaN(position.HorizontalAccuracy()))
{
if (position.HorizontalAccuracy() == KHorizontalAccuracy)
{
_LIT(KError, "Horizontal Accuracy not cleared for ");
AddMessageL(KError, aPositionType, EErrorMessage);
allIsCleared = EFalse;
}
}
if (!Math::IsNaN(position.VerticalAccuracy()))
{
if (position.VerticalAccuracy() == KVerticalAccuracy)
{
_LIT(KError, "Vertical Accuracy not cleared for ");
AddMessageL(KError, aPositionType, EErrorMessage);
allIsCleared = EFalse;
}
}
if (!Math::IsNaN(position.Latitude()))
{
if (position.Latitude() == KLatitude)
{
_LIT(KError, "Latitude not cleared for ");
AddMessageL(KError, aPositionType, EErrorMessage);
allIsCleared = EFalse;
}
}
if (!Math::IsNaN(position.Longitude()))
{
if (position.Longitude() == KLongitude)
{
_LIT(KError, "Longitude not cleared for ");
AddMessageL(KError, aPositionType, EErrorMessage);
allIsCleared = EFalse;
}
}
if (!Math::IsNaN(position.Altitude()))
{
if (position.Altitude() == KAltitude)
{
_LIT(KError, "Altitude not cleared for ");
AddMessageL(KError, aPositionType, EErrorMessage);
allIsCleared = EFalse;
}
}
if (allIsCleared)
{
_LIT(KInfo, "All TPositionInfo fields were cleared for ");
AddMessageL(KInfo, aPositionType, EInfoMessage);
}
}
void XQLocationPrivate::DeliverPositionerResults(TPositionSatelliteInfo aPositionInfo)
{
TPosition pos;
aPositionInfo.GetPosition(pos);
// Handle speed reporting
float speed = 0;
if (speedAvailable) {
// Positioning module is able to offer speed information
TCourse course;
aPositionInfo.GetCourse(course);
speed = course.Speed();
if (isnan(speed)) {
speed = 0;
}
} else {
// Positioning module does not offer speed information
// => Speed is calculated using position information & timestamps
TTime posTime;
TTimeIntervalSeconds interval;
for (int i = iPositions.Count()-1 ; i >= 0; i--) {
if (pos.Time().SecondsFrom(iPositions[i].Time(),interval) == KErrNone) {
if (interval.Int() > 10) {
pos.Speed(iPositions[i], speed);
break;
}
}
}
while (iPositions.Count() > 0) {
if (pos.Time().SecondsFrom(iPositions[0].Time(),interval) == KErrNone) {
if (interval.Int() > 60) {
iPositions.Remove(0);
} else {
break;
}
}
}
if (iPositions.Count() > 0) {
if (pos.Time().SecondsFrom(iPositions[iPositions.Count()-1].Time(),interval) == KErrNone) {
if (interval.Int() > 1) {
iPositions.Append(pos);
}
}
} else {
iPositions.Append(pos);
}
// Accept speed from range 0.01 m/s (0.036 km/h) to 200 m/s (720 km/h)
if (speed < 0.01 || speed > 200) {
speed = 0;
}
}
if (speed != iPreviousSpeed) {
emit ipParent->speedChanged(speed);
}
iPreviousSpeed = speed;
// Handle satellite information reporting
if (satelliteInfoAvailable) {
if (aPositionInfo.NumSatellitesInView() != iPreviousNumSatellitesInView) {
emit ipParent->numberOfSatellitesInViewChanged(aPositionInfo.NumSatellitesInView());
}
iPreviousNumSatellitesInView = aPositionInfo.NumSatellitesInView();
if (aPositionInfo.NumSatellitesUsed() != iPreviousNumSatellitesUsed) {
emit ipParent->numberOfSatellitesUsedChanged(aPositionInfo.NumSatellitesUsed());
}
iPreviousNumSatellitesUsed = aPositionInfo.NumSatellitesUsed();
}
// Handle position information reporting
if (iPreviousPosition.Latitude() != pos.Latitude() ||
iPreviousPosition.Longitude() != pos.Longitude() ||
iPreviousPosition.Altitude() != pos.Altitude()) {
if (!isnan(pos.Latitude()) || !isnan(pos.Longitude()) || !isnan(pos.Altitude())) {
emit ipParent->locationChanged(pos.Latitude(),pos.Longitude(),pos.Altitude(),speed);
}
if (iPreviousPosition.Latitude() != pos.Latitude()) {
if (!isnan(pos.Latitude())) {
emit ipParent->latitudeChanged(pos.Latitude(),pos.HorizontalAccuracy());
}
}
if (iPreviousPosition.Longitude() != pos.Longitude()) {
if (!isnan(pos.Longitude())) {
emit ipParent->longitudeChanged(pos.Longitude(),pos.HorizontalAccuracy());
}
}
if (iPreviousPosition.Altitude() != pos.Altitude()) {
if (!isnan(pos.Altitude())) {
emit ipParent->altitudeChanged(pos.Altitude(),pos.VerticalAccuracy());
}
}
}
iPreviousPosition = pos;
if (iSingleUpdate) {
stopUpdates();
iSingleUpdate = EFalse;
}
}
EXPORT_C TBool T_LbsUtils::Compare_PosInfo(const TPositionInfoBase& aPosInfoSideA, const TPositionInfoBase& aPosInfoSideB, TComparisonAccuracyType aCmpAccuracy)
{
// TODO compare base class items, such as module id, position mode, etc.
TUint32 typeA = aPosInfoSideA.PositionClassType();
TUint32 typeB = aPosInfoSideB.PositionClassType();
// Compare TPositionInfo type items.
if(typeA & typeB & EPositionInfoClass)
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Both positions are of type EPositionInfoClass");
const TPositionInfo& posInfoSideA = reinterpret_cast<const TPositionInfo&>(aPosInfoSideA);
const TPositionInfo& posInfoSideB = reinterpret_cast<const TPositionInfo&>(aPosInfoSideB);
TPosition posSideA;
TPosition posSideB;
posInfoSideA.GetPosition(posSideA);
posInfoSideB.GetPosition(posSideB);
// Carry out an exact check when comparing items.
if (EExactAccuracy == aCmpAccuracy)
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Comparing positions for exact match");
// Compare latitude.
if (Math::IsNaN(posSideA.Latitude()) && Math::IsNaN(posSideB.Latitude()))
;
else if (posSideA.Latitude() != posSideB.Latitude())
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Positions don't match!");
TESTLOG3(ELogP1, "Latitudes %d and %d respectively", posSideA.Latitude(), posSideB.Latitude());
return EFalse;
}
// Compare longitude.
if (Math::IsNaN(posSideA.Longitude()) && Math::IsNaN(posSideB.Longitude()))
;
else if (posSideA.Longitude() != posSideB.Longitude())
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Positions don't match!");
TESTLOG3(ELogP1, "Longitudes %d and %d respectively", posSideA.Longitude(), posSideB.Longitude());
return EFalse;
}
// Compare altitude.
if (Math::IsNaN(posSideA.Altitude()) && Math::IsNaN(posSideB.Altitude()))
;
else if (posSideA.Altitude() != posSideB.Altitude())
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Positions don't match!");
TESTLOG3(ELogP1, "Altitudes %d and %d respectively", posSideA.Altitude(), posSideB.Altitude());
return EFalse;
}
// Compare datum.
if (posSideA.Datum() != posSideB.Datum())
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Positions don't match!");
TESTLOG3(ELogP1, "Datums %d and %d respectively", posSideA.Datum(), posSideB.Datum());
return EFalse;
}
// Compare horizontal accuracy.
if (Math::IsNaN(posSideA.HorizontalAccuracy()) && Math::IsNaN(posSideB.HorizontalAccuracy()))
;
else if (posSideA.HorizontalAccuracy() != posSideB.HorizontalAccuracy())
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Positions don't match!");
TESTLOG3(ELogP1, "Horizontal Accuracies %d and %d respectively", posSideA.HorizontalAccuracy(), posSideB.HorizontalAccuracy());
return EFalse;
}
// Compare vertical accuracy.
if (Math::IsNaN(posSideA.VerticalAccuracy()) && Math::IsNaN(posSideB.VerticalAccuracy()))
;
else if (posSideA.VerticalAccuracy() != posSideB.VerticalAccuracy())
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Positions don't match!");
TESTLOG3(ELogP1, "Vertical Accuracies %d and %d respectively", posSideA.VerticalAccuracy(), posSideB.VerticalAccuracy());
return EFalse;
}
}
else
{
// Check latitude + longitude using horz accuracy.
TReal horzAct = posSideA.HorizontalAccuracy(); // Use the verify accuracy value (which is side A).
TReal distance ;
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Comparing positions for 'rough' match");
// if(NAN != horzAct)
{
// The following is a temporary patch until TPositionInfo.Distance() is implemented:
/*
from http://www.movable-type.co.uk/scripts/GIS-FAQ-5.1.html
presuming a spherical Earth with radius R (see below), and the locations of the two points in spherical coordinates (longitude and latitude) are lon1,lat1 and lon2,lat2 then the
Haversine Formula (from R.W. Sinnott, "Virtues of the Haversine", Sky and Telescope, vol. 68, no. 2, 1984, p. 159):
dlon = lon2 - lon1
dlat = lat2 - lat1
a = sin^2(dlat/2) + cos(lat1) * cos(lat2) * sin^2(dlon/2)
c = 2 * arcsin(min(1,sqrt(a)))
d = R * c
will give mathematically and computationally exact results.
*/
const TReal pi = 3.141592653589793;
const TReal earthRadius = 6367 * 1000; // earth radius in metres
TReal32 latA = posSideA.Latitude() * (pi/180);
TReal32 latB = posSideB.Latitude() * (pi/180);
TReal32 lonA = posSideA.Longitude() * (pi/180);
TReal32 lonB = posSideB.Longitude() * (pi/180);
TReal dlon = (lonB - lonA);
TReal dlat = (latB - latA);
TReal sin_half_dlat, sin_half_dlon, coslatA, coslatB;
Math::Sin(sin_half_dlat, dlat/2);
Math::Sin(sin_half_dlon, dlon/2);
Math::Cos(coslatA, latA);
Math::Cos(coslatB, latB);
TReal a = (sin_half_dlat * sin_half_dlat) + (coslatA * coslatB * (sin_half_dlon * sin_half_dlon));
TReal sqrt_a;
Math::Sqrt(sqrt_a, a);
TReal arcsinmin;
TReal min = Min(static_cast<TReal>(1), sqrt_a);
Math::ASin(arcsinmin, min);
distance = earthRadius * (2 * arcsinmin);
//__ASSERT_ALWAYS(!Math::IsNaN(distance), User::Panic(_L("Lbs Test Utils"), KErrGeneral));
if(Math::IsNaN(latA) || Math::IsNaN(lonA) || Math::IsNaN(horzAct))
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Positions don't match because contains NaNs!");
return EFalse;
}
else if(distance > horzAct + 30) // lrm allow for 30m discrepency for now TO DO figure out whether we should be able to check finer accuracy
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Positions don't match because distance greater than reported accuracy + margin!");
return EFalse;
}
}
/* put back later:
TReal32 horzAct = posSideA.HorizontalAccuracy(); // Use the verify accuracy value (which is side A).
TReal32 distance ;
posSideA.Distance(posSideB, distance);
if (distance > horzAct)
return EFalse;
// Check altitude using vert accuracy.
TReal32 vertAct = posSideA.VerticalAccuracy(); // Use the verify accuracy value (which is side A).
TReal32 height = Abs(posSideA.Altitude() - posSideB.Altitude());
if (height > vertAct)
return EFalse;
*/
}
// TODO, we don't compare times, not sure if this is something we would do later on
// if (posSideA.Time() != posSideB.Time())
// return EFalse;
return ETrue;
}
// Compare TPositionCourseInfo type items.
if (typeA & typeB & EPositionCourseInfoClass)
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Both positions are of type EPositionCourseInfoClass");
// TODO
}
// Compare TPositionSatelliteInfo type items.
if (typeA & typeB & EPositionSatelliteInfoClass)
{
TESTLOG(ELogP1, "T_LbsUtils::Compare_PosInfo() Both positions are of type EPositionSatelliteInfoClass");
// TODO
}
/* For extended tests when we have them.
if (infoBase.PositionClassType() & EPositionClassTestExtension)
{
}
*/
return EFalse;
}
// ---------------------------------------------------------
// 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;
}
}
//HBufC8* CAgentPosition::GetGPSBufferL(TPosition pos) // original MB
HBufC8* CAgentPosition::GetGPSBufferL(TPositionSatelliteInfo satPos)
{
/*
* If the number of satellites used to calculate the coordinates is < 4, we don't use
* the fix
*/
if(satPos.NumSatellitesUsed() < 4 )
return HBufC8::NewL(0);
CBufBase* buffer = CBufFlat::NewL(50);
CleanupStack::PushL(buffer);
TGPSInfo gpsInfo;
// retrieve TPosition
TPosition pos;
satPos.GetPosition(pos);
// insert filetime timestamp
TTime now;
now.UniversalTime();
//TInt64 filetime = GetFiletime(now);
TInt64 filetime = TimeUtils::GetFiletime(now);
gpsInfo.filetime.dwHighDateTime = (filetime >> 32);
gpsInfo.filetime.dwLowDateTime = (filetime & 0xFFFFFFFF);
gpsInfo.gps.FixType = GPS_FIX_3D; // we are sure at least 4 satellites have been used
// insert lat-long-alt-time
gpsInfo.gps.dblLatitude = pos.Latitude();
gpsInfo.gps.dblLongitude = pos.Longitude();
gpsInfo.gps.flAltitudeWRTSeaLevel = pos.Altitude();
gpsInfo.gps.stUTCTime = TSystemTime( pos.Time() );
gpsInfo.gps.dwValidFields = (GPS_VALID_UTC_TIME | GPS_VALID_LATITUDE | GPS_VALID_LONGITUDE | GPS_VALID_ALTITUDE_WRT_SEA_LEVEL);
gpsInfo.gps.dwSatelliteCount = satPos.NumSatellitesUsed();
gpsInfo.gps.dwValidFields |= GPS_VALID_SATELLITE_COUNT;
gpsInfo.gps.dwSatellitesInView = satPos.NumSatellitesInView();
gpsInfo.gps.dwValidFields |= GPS_VALID_SATELLITES_IN_VIEW;
gpsInfo.gps.flHorizontalDilutionOfPrecision = satPos.HorizontalDoP();
gpsInfo.gps.dwValidFields |= GPS_VALID_HORIZONTAL_DILUTION_OF_PRECISION;
gpsInfo.gps.flVerticalDilutionOfPrecision = satPos.VerticalDoP();
gpsInfo.gps.dwValidFields |= GPS_VALID_VERTICAL_DILUTION_OF_PRECISION;
TCourse course;
satPos.GetCourse(course);
gpsInfo.gps.flSpeed = course.Speed();
gpsInfo.gps.dwValidFields |= GPS_VALID_SPEED;
gpsInfo.gps.flHeading = course.Heading();
gpsInfo.gps.dwValidFields |= GPS_VALID_HEADING;
/*
* Additional data regarding the satellites can be obtained using the TSatelliteData structure.
* Example:
*/
/*
TInt numSat = satPos.NumSatellitesInView();
TInt err = KErrNone;
for (int i=0; i<numSat; i++) {
// Get satellite data
TSatelliteData satData;
err = satPos.GetSatelliteData(i,satData);
if(err != KErrNone)
{
continue;
}
// Get info
// See TSatelliteData definition for more methods.
TReal32 azimuth = satData.Azimuth();
TInt satSignalStrength = satData.SignalStrength();
}*/
TUint32 type = TYPE_GPS;
buffer->InsertL(0, &type, sizeof(TUint32));
buffer->InsertL(buffer->Size(), &gpsInfo, sizeof(TGPSInfo));
HBufC8* result = buffer->Ptr(0).AllocL();
CleanupStack::PopAndDestroy(buffer);
return result;
}
