/*
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;
}
// ---------------------------------------------------------
// 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);
}
//
// 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 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);
}
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)));
}
// ---------------------------------------------------------
// 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);
}
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);
}
}
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());
}
// ---------------------------------------------------------
// 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;
}
}
void CNetworkGateway::ProcessNetworkLocationMessage(const TLbsNetLocMsgBase& aMessage)
{
LBSLOG(ELogP2, "CNetworkGateway::ProcessNetworkLocationMessage:");
LBSLOG2(ELogP3, "Type : %d", aMessage.Type());
switch (aMessage.Type())
{
case TLbsNetLocMsgBase::ENetLocMsgNetworkLocationRequest:
{
TInt reason = KErrNone;
const TLbsNetLocNetworkLocationRequestMsg& req = static_cast<const TLbsNetLocNetworkLocationRequestMsg&>(aMessage);
iCurrentNetLocReqId = req.SessionId();
if (req.Quality().MaxFixTime() == 0)//answer req with incorrect session id
{
iCurrentNetLocReqId.SetSessionNum(999);
TLbsNetLocNetworkLocationCompleteMsg msg(iCurrentNetLocReqId, reason);
iNetworkLocationChannel->SendNetworkLocationMessage(msg);
}
else if (req.Quality().MaxFixTime() == 1)//answer req with unknown response type
{
TLbsNetLocNetworkLocationCancelMsg msg(iCurrentNetLocReqId, reason);
iNetworkLocationChannel->SendNetworkLocationMessage(msg);
}
else
{
TLbsNetLocNetworkLocationCompleteMsg msg(iCurrentNetLocReqId, reason);
iNetworkLocationChannel->SendNetworkLocationMessage(msg);
}
// for testing return a fixed test location
TPositionCourseInfo posInfo;
TPosition pos;
pos.SetCoordinate(50, 80);
posInfo.SetPosition(pos);
TCourse course;
course.SetSpeed(10.0);
course.SetVerticalSpeed(20.0);
course.SetHeading(30.0);
course.SetSpeedAccuracy(1.0);
course.SetVerticalSpeedAccuracy(2.0);
course.SetHeadingAccuracy(3.0);
course.SetCourse(40.0);
course.SetCourseAccuracy(4.0);
posInfo.SetCourse(course);
iNetworkLocationChannel->SetReferencePosition(iCurrentNetLocReqId, posInfo);
break;
}
case TLbsNetLocMsgBase::ENetLocMsgNetworkLocationCancel:
{
const TLbsNetLocNetworkLocationCancelMsg& cancel = static_cast<const TLbsNetLocNetworkLocationCancelMsg&>(aMessage);
// for test netlocmanager, return the location info directly without sending request to network protocol
iCurrentNetLocReqId = cancel.SessionId();
TInt reason = KErrNone;
TLbsNetLocNetworkLocationCompleteMsg msg(iCurrentNetLocReqId, reason);
iNetworkLocationChannel->SendNetworkLocationMessage(msg);
break;
}
case TLbsNetLocMsgBase::ENetLocMsgNetworkLocationComplete:
default:
{
break;
}
}
}
EXPORT_C void RLbsLocMonitorAreaPositioner::GetLastKnownPositionArea(TPositionInfoBase& aPosInfo,
TPositionAreaInfoBase& aAreaInfo,
const TPosAreaReqParams& aParameters,
TRequestStatus& aStatus)const
{
const_cast<RLbsLocMonitorAreaPositioner*>(this)->SetLKPARequestStatus(&aStatus);
aStatus = KRequestPending;
// Return a dummy area info
switch(aParameters.iPositionAreaType)
{
case EPositionAreaInfoClass:
{
TPositionAreaInfo& areainfo = static_cast<TPositionAreaInfo &>(aAreaInfo);
areainfo.SetArea(TPositionAreaInfo::EAreaCity);
break;
}
case (EPositionAreaExtendedInfoClass+EPositionAreaInfoClass):
{
TPositionAreaExtendedInfo& areaextendedinfo = static_cast<TPositionAreaExtendedInfo &>(aAreaInfo);
areaextendedinfo.SetArea(TPositionAreaInfo::EAreaCity);
areaextendedinfo.SetCellIdMatch(ETrue);
areaextendedinfo.SetLocationAreaCodeMatch(ETrue);
areaextendedinfo.SetMobileCountryCodeMatch(ETrue);
areaextendedinfo.SetMobileNetworkCodeMatch(ETrue);
break;
}
}
// Return a dummy position
TPositionInfo& posinfo = static_cast<TPositionInfo &>(aPosInfo);
TPosition testpos;
testpos.SetCoordinate(DUMMY_LAST_KNOWN_POS_LATITUDE1, DUMMY_LAST_KNOWN_POS_LONGITUDE1, DUMMY_LAST_KNOWN_POS_ALTITUDE1);
posinfo.SetPosition(testpos);
// The values used in the timer for delaying the response from the test location monitor
// to the location server
TTimeIntervalMicroSeconds32 delay, interval;
delay = 2000000; //2 sec
interval = 100000000;
// 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].
// Modify the behaviour of the Location Monitor based on the testcase using the value of the
// property
TInt testcase, propRead;
propRead = iTestLKPAreaKey.Get(KLocSrvTestSuite, KLbsLocMonitorTestLKPAreaKey,testcase);
if (propRead==KErrNone)
{
switch(testcase)
{
case EGetLKPosAreaNotFound:
{
TRequestStatus* pStat = &aStatus;
User::RequestComplete(pStat, KErrNotFound);
return;
}
case EGetLKPAreaTimedOut:
delay = 1000000000;;
break;
default:
break;
}
}
iDelayedLKPAreaUpdate->Start(delay, interval, TCallBack(LKPATimerCallback, const_cast<RLbsLocMonitorAreaPositioner*>(this)));
}
/*
This method returns a position and area info to the client.
*/
TInt RLbsLocMonitorDb::GetPosition(TPosition& aPosition, const RPointerArray<TLbsLocMonitorAreaInfoBase>& /*aAreaInfo*/, TPositionAreaExtendedInfo& aMatchingAreaInfo, TRequestStatus& aStatus)
{
LBSLOG(ELogP1, "RLbsLocMonitorDb::GetPosition()");
TInt completionCode = KErrNone;
aStatus = KRequestPending;
iCallCount ++;
if (iFailNextRequest)
{
completionCode = KErrNotFound;
iFailNextRequest = EFalse;
}
else if(iShortDelayNextRequest || iLongDelayNextRequest)
{
// Remember client request's return params and
// force a delay.
iClientPosition = &aPosition;
iClientMatchAreaInfo = &aMatchingAreaInfo;
iClientStatus = &aStatus;
if (!iTimer->IsActive())
{
TInt delayInMicroSecs = iLongDelayNextRequest?15000000:1000000; // 1 or 15 seconds
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(KLatGetPos1, KLongGetPos1);
// Set a match level as if it was found in the DB
aMatchingAreaInfo.SetArea(TPositionAreaInfo::EAreaCity);
aMatchingAreaInfo.SetMobileCountryCodeMatch(ETrue);
aMatchingAreaInfo.SetMobileNetworkCodeMatch(ETrue);
aMatchingAreaInfo.SetLocationAreaCodeMatch(ETrue);
aMatchingAreaInfo.SetCellIdMatch(ETrue);
break;
// Return different values for second and later requests
// that occurred in the same test.
default:
aPosition.SetCoordinate(KLatGetPos2, KLongGetPos2);
// Set a match level as if it was found in the DB
aMatchingAreaInfo.SetArea(TPositionAreaInfo::EAreaCountry);
aMatchingAreaInfo.SetMobileCountryCodeMatch(ETrue);
aMatchingAreaInfo.SetMobileNetworkCodeMatch(EFalse);
aMatchingAreaInfo.SetLocationAreaCodeMatch(EFalse);
aMatchingAreaInfo.SetCellIdMatch(EFalse);
break;
}
}
TRequestStatus* status = &aStatus;
User::RequestComplete(status, completionCode);
return KErrNone;
}
void CNetworkPsy2::TimerCompleted()
{
TPsyConfig& config(iPsyConfigArray[iCurrentIndex]);
if(config.iType==TPsyConfig::EConfigLRResponse)
{
//If no pending LR, then just return
if(!iRequestStatus)
{
return;
}
TInt err = config.iData.iLRConfig.iErr;
//complete location request
if(iPositionInfoBase->PositionClassType() & EPositionInfoClass)
{
//Set TPositionInfo
TPosition pos;
pos.SetCoordinate(
config.iData.iLRConfig.iLat,
config.iData.iLRConfig.iLon,
config.iData.iLRConfig.iAlt);
TPositionInfo* posInfo = reinterpret_cast<TPositionInfo*>(iPositionInfoBase);
posInfo->SetPosition(pos);
}
if(iPositionInfoBase->PositionClassType() & EPositionGenericInfoClass)
{
//Set HGeneric Info
HPositionGenericInfo* genInfo =
static_cast<HPositionGenericInfo*>(iPositionInfoBase);
if(genInfo->IsRequestedField(EPositionFieldNMEASentences))
{
genInfo->SetValue(EPositionFieldNMEASentences, TInt8(1));
HBufC8* nmea = NULL;
TRAP(err, nmea = HBufC8::NewL(config.iData.iLRConfig.iNmeaDataSize));
if(KErrNone == err)
{
TPtr8 nmeaPtr(nmea->Des());
nmeaPtr.Fill('H', config.iData.iLRConfig.iNmeaDataSize);
err = genInfo->SetValue(EPositionFieldNMEASentences+1, *nmea);
}
delete nmea;
}
}
CompleteRequest(err);
if(config.iData.iLRConfig.iNumOfResponse>1)
{
config.iData.iLRConfig.iNumOfResponse--;
}
else if(config.iData.iLRConfig.iNumOfResponse>0)
{
iCurrentIndex++;
}
else
{
//0 means forever response with this
}
}
else //ECinfigModuleStatus
{
//Change module status
TPositionModuleStatus modStatus;
modStatus.SetDataQualityStatus(config.iData.iStatusConfig.iDataQuality);
modStatus.SetDeviceStatus(config.iData.iStatusConfig.iDeviceStatus);
MPositionerStatus* observer = PositionerStatus();
observer->ReportStatus(modStatus);
iCurrentIndex++;
}
iTimer->Cancel();
if(iCurrentIndex>=iPsyConfigArray.Count())
{
//When all items are used, then clean the config items
iPsyConfigArray.Reset();
iCurrentIndex = 0;
}
StartTimerIfNeeded();
}
