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;
}
const TDesC& CTTGPSLoggerPositioningMethod::SettingTextL() // show text
{
CDesC16ArrayFlat *itemArray = new (ELeave) CDesC16ArrayFlat(5);
CleanupStack::PushL(itemArray); // in case the appends leave
RPositionServer iPositionServer;
RPositioner iPositioner;
User::LeaveIfError(iPositionServer.Connect());
User::LeaveIfError(iPositioner.Open(iPositionServer));
TUint aModules = 0;
// Get the available numbers of modules
User::LeaveIfError(iPositionServer.GetNumModules(aModules));
TPositionModuleInfo info;
// Prepare itemArray and itemArrayDetails
itemArray->AppendL(_L("(Default)"));
for(TUint i = 0; i < aModules; i++)
{
if ((iPositionServer.GetModuleInfoByIndex(i,info) == KErrNone) && (info.IsAvailable()))
{
TBuf<200> smallBuffer;
smallBuffer.Zero();
info.GetModuleName(smallBuffer);
itemArray->AppendL(smallBuffer);
}
}
iPositioner.Close();
iPositionServer.Close();
iDispl.Zero();
if ((iPosMethod>aModules)||(iPosMethod<0))
iPosMethod=0; // Default
iDispl.Copy((*itemArray)[iPosMethod]);
CleanupStack::PopAndDestroy(); // itemArray
return(iDispl);
}
TVerdict CT_LbsHybridCombinedStep_Tracking02::doTestStepL()
{
INFO_PRINTF1(_L("CT_LbsHybridCombinedStep_Tracking02::doTestStepL()"));
// Stop the test if the preable failed
TESTL(TestStepResult() == EPass);
const TInt KTimeOut = 80*1000*1000;
// data declarations common to MOLR & MTLR
TBool emergency = EFalse;
TInt reason = KErrNone;
MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
TLbsNetPosRequestQuality quality = ArgUtils::Quality();
TLbsNetPosRequestMethod method = ArgUtils::RequestHybridMethod();
TPositionSatelliteInfo* getPositionInfo = NULL;
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask serviceMask1 = MLbsNetworkProtocolObserver::EServiceSelfLocation;
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask serviceMask2 = MLbsNetworkProtocolObserver::EServiceNone;
TLbsNetPosRequestPrivacy privacy = ArgUtils::Privacy();
TLbsExternalRequestInfo requestInfo = ArgUtils::RequestInfo();
TNetProtocolResponseType mType;
// Protocol Module receives the cababilities message as LBS starts up...
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgGetCurrentCapabilitiesResponse);
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt;
cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
CleanupStack::PopAndDestroy(cleanupCnt);
INFO_PRINTF1(_L("ENetMsgGetCurrentCapabilitiesResponse got"));
// Create Client Objects...
RPositionServer server;
TInt connectError = server.Connect();
TESTL(KErrNone == connectError);
CleanupClosePushL(server);
RPositioner pos;
TESTL(KErrNone == pos.Open(server));
CleanupClosePushL(pos);
CPosServerWatcher *pWatch = CPosServerWatcher::NewLC(pos, *this);
// set client update options
TBool trackingEnabled = ETrue;
if (trackingEnabled)
{
T_LbsUtils utils;
TPtrC configFileName;
_LIT(KUpdateOptionsFile, "agps_module_update_file");
GetStringFromConfig(ConfigSection(), KUpdateOptionsFile, configFileName);
utils.GetConfigured_ModuleUpdateOptionsL(configFileName, ConfigSection(), iUpdateOpts);
pos.SetUpdateOptions(iUpdateOpts);
}
// Client Send - self locate request... TB mode selected in Admin...
pWatch->IssueNotifyPositionUpdate();
INFO_PRINTF1(_L("NotifyPositionUpdate sent"));
// Get current time.
iClientInitialRequestTime.UniversalTime();
// LBS->PM :: RequestSelfLocation()
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRequestSelfLocation);
INFO_PRINTF1(_L("RequestSelfLocation got"));
// check the Client AGPS Usage Flag is as expected at the NPE Hybrid GPS module...
// Process the response.
TLbsNetSessionId* sessionId = NULL;
TLbsNetPosRequestOptionsAssistance* opts = NULL;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts);
TBool qualitycheck = ArgUtils::CompareQuality( opts,
ETrue,
KMinHorizontalAcc,
KMinVerticalAcc,
KTestMaxFixTime,
0,
EAssistanceDataReferenceTime,
(TPositionModuleInfo::ETechnologyTerminal
| TPositionModuleInfo::ETechnologyAssisted)
);
TESTL(qualitycheck);
iSessionId.SetSessionNum(sessionId->SessionNum());
iSessionId.SetSessionOwner(sessionId->SessionOwner());
CleanupStack::PopAndDestroy(cleanupCnt);
sessionId = NULL;
opts = NULL;
// PM->LBS ProcessStatusUpdate(EServiceSelfLocation)
serviceMask1 = MLbsNetworkProtocolObserver::EServiceSelfLocation;
iProxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask1);
INFO_PRINTF1(_L("ProcessStatusUpdate sent"));
// PM->LBS ProcessLocationUpdate(SessionId, RefPosition)
TPositionInfo refPosInfo = ArgUtils::MolrReferencePositionInfo();
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
INFO_PRINTF1(_L("ProcessLocationUpdate sent"));
// LBS->CLIENT OnNotifyPositionUpdate()
CheckForObserverEventTestsL(KTimeOut, *this);
TEST(iClientPosUpdateCount==1);
// second request... the interval is 5 seconds..
// CLIENT->LBS IssueNotifyPositionUpdate();
pWatch->IssueNotifyPositionUpdate();
INFO_PRINTF1(_L("second NotifyPositionUpdate sent"));
// an MTLR now happens with Max Fix Time before the client interval expires..
// (max fix time == 12 seconds)
// << ProcessStatusUpdate()
serviceMask1 |= MLbsNetworkProtocolObserver::EServiceMobileTerminated;
iProxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask1);
INFO_PRINTF1(_L("ProcessStatusUpdate sent"));
// PM->LBS ProcessPrivacyRequest()
emergency = ETrue;
privacy = ArgUtils::Privacy();
requestInfo = ArgUtils::RequestInfo();
iProxy->CallL(ENetMsgProcessPrivacyRequest, &iSessionId2, &emergency, &privacy, &requestInfo);
INFO_PRINTF1(_L("ProcessPrivacyRequest sent"));
// LBS->NRH Callback from RespondNetworkLocationRequest(ERequestAccepted)
CheckForObserverEventTestsL(KTimeOut, *this);
// NRH->PM Respond Privacy Request
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRespondPrivacyRequest);
INFO_PRINTF1(_L("RespondPrivacyRequest got"));
TLbsNetSessionId* getSessionId = NULL;
CLbsNetworkProtocolBase::TLbsPrivacyResponse getPrivacy;
cleanupCnt = 0;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondPrivacyRequest, &getSessionId, &getPrivacy);
TESTL(getSessionId->SessionNum()==iSessionId2.SessionNum());
TESTL(getPrivacy==CLbsNetworkProtocolBase::EPrivacyResponseAccepted);
CleanupStack::PopAndDestroy(cleanupCnt);
// PM->LBS ProcessLocationUpdate()
TPositionInfo positionInfo = ArgUtils::ReferencePositionInfo();
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId2, &positionInfo);
INFO_PRINTF1(_L("ProcessLocationUpdate sent"));
// PM->LBS ProcessAssistanceData()
TLbsAsistanceDataGroup dataRequestMask = EAssistanceDataReferenceTime;
RLbsAssistanceDataBuilderSet assistanceData2;
ArgUtils::PopulateLC(assistanceData2);
reason = KErrNone;
iProxy->CallL(ENetMsgProcessAssistanceData, &dataRequestMask, &assistanceData2, &reason);
CleanupStack::PopAndDestroy();
INFO_PRINTF1(_L("ProcessAssistanceData sent"));
// PM->LBS ProcessLocationRequest(TB) (max fix time == 12 seconds)
service = MLbsNetworkProtocolObserver::EServiceMobileTerminated;
quality = ArgUtils::QualityAlpha2();
method = ArgUtils::RequestTerminalBasedMethod();
iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId2, &emergency, &service, &quality, &method);
INFO_PRINTF1(_L("PM->LBS ProcessLocationRequest(TB) sent"));
// LBS->NRH Callback from ProcessNetworkPostionUpdate(refPosition)
CheckForObserverEventTestsL(KTimeOut, *this);
// LBS->NRH Callback from ProcessNetworkPostionUpdate(GPS Location)
CheckForObserverEventTestsL(KTimeOut, *this);
// check the Client AGPS Usage Flag is as expected at the NPE Hybrid GPS module...
// LBS->PM RequestAssistanceData(0)
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
INFO_PRINTF1(_L("RequestAssistanceData got"));
TLbsAsistanceDataGroup dataGroup;
CleanupStack::PopAndDestroy(iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup));
TESTL(dataGroup == EAssistanceDataNone);
// LBS->PM RespondLocationRequest()
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRespondLocationRequest);
getSessionId = NULL;
TInt getReason = KErrNone;
getPositionInfo = NULL;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);
TESTL(getSessionId->SessionNum() == iSessionId2.SessionNum());
TESTL(getReason == KErrNone);
CleanupStack::PopAndDestroy(cleanupCnt);
INFO_PRINTF1(_L("RespondLocationRequest got"));
// PM->LBS ProcessSessionComplete()
reason = KErrNone;
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId2, &reason);
INFO_PRINTF1(_L("ProcessSessionComplete sent"));
// PM->LBS ProcessStatusUpdate() - still doing the self locate...
serviceMask2 = MLbsNetworkProtocolObserver::EServiceSelfLocation;
iProxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask2);
INFO_PRINTF1(_L("ProcessStatusUpdate sent"));
// LBS->NRH Callback from ProcessRequestComplete()
CheckForObserverEventTestsL(KTimeOut, *this);
// the GPS Module should wait *nearly* 10 seconds (the tracking interval
// for this test) before continuing to process the location request...
// LBS->PM CurrentCapabilitiesResponse - informing the PM we're tracking...
mType = iProxy->WaitForResponse(KTimeOut);
TESTL(mType == ENetMsgGetCurrentCapabilitiesResponse);
// LBS->PM RequestAssistanceData()
TLbsAsistanceDataGroup dataMask;
mType = iProxy->WaitForResponse(KTimeOut);
TESTL(mType == ENetMsgRequestAssistanceData);
cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// check the Client AGPS Usage Flag is as expected at the NPE Hybrid GPS module...
// PM->LBS ProcessAssistanceData()
dataMask = EAssistanceDataReferenceTime;
RLbsAssistanceDataBuilderSet assistanceData;
ArgUtils::PopulateLC(assistanceData);
reason = KErrNone;
iProxy->CallL(ENetMsgProcessAssistanceData, &dataMask, &assistanceData, &reason);
CleanupStack::PopAndDestroy(); // assistanceData
// PM->LBS ProcessLocationRequest() (NRH Request)
service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
quality = ArgUtils::Quality();
method = ArgUtils::RequestHybridMethod();
iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
// LBS->PM RequestAssistanceData()
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
TESTL(dataMask == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// check the Client AGPS Usage Flag is as expected at the NPE Hybrid GPS module...
// LBS->PM RespondLocationRequest()
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRespondLocationRequest);
sessionId = NULL;
reason = KErrNone;
getPositionInfo = NULL;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &getPositionInfo);
TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
TESTL(reason == KErrNone);
// PM->LBS ProcessLocationUpdate(SessionId, FinalNetworkPosition)
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, getPositionInfo);
CleanupStack::PopAndDestroy(cleanupCnt);
// Client recv - the gps position determined by the gps module.
CheckForObserverEventTestsL(KTimeOut, *this);
TESTL(iClientPosUpdateCount==2);
// End of second client request ********************
// close the client session
pos.Close();
// LBS->PM CurrentCapabilitiesResponse - informing the PM we're no longer tracking...
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgGetCurrentCapabilitiesResponse);
// LBS->PM CurrentCapabilitiesResponse - cancel the self location request.
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgCancelSelfLocation);
// PM->LBS ProcessSessionComplete()
reason = KErrNone;
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
// PM->LBS ProcessStatusUpdate()
serviceMask2 = MLbsNetworkProtocolObserver::EServiceNone;
iProxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask2);
// Wait for 10 seconds to ensure no additional responses turn up.
TInt delta = 10 * 1000 * 1000;
mType = iProxy->WaitForResponse(delta);
TESTL(mType == ENetMsgTimeoutExpired);
// Done. Now cleanup...
// all associated with MOLR Positioning Client
CleanupStack::PopAndDestroy(pWatch);
CleanupStack::PopAndDestroy(); // pos
CleanupStack::PopAndDestroy(); // server
return TestStepResult();
}
void CTTGPSLoggerPositioningMethod::EditItemL(TBool aCalledFromMenu) // edit text
{
CDesC16ArrayFlat *itemArray = new (ELeave) CDesC16ArrayFlat(20);
CDesC16ArrayFlat *itemArrayDetails = new (ELeave) CDesC16ArrayFlat(20);
CleanupStack::PushL(itemArray); // in case the appends leave
CleanupStack::PushL(itemArrayDetails); // in case the appends leave
RPositionServer iPositionServer;
RPositioner iPositioner;
User::LeaveIfError(iPositionServer.Connect());
User::LeaveIfError(iPositioner.Open(iPositionServer));
itemArray->AppendL(_L("(Info on all modules)"));
itemArray->AppendL(_L("(Default)"));
TUint aModules = 0;
TInt defaultModule=-1;
// Get the available numbers of modules
User::LeaveIfError(iPositionServer.GetNumModules(aModules));
TPositionModuleInfo info;
TPositionModuleId aModuleId;
iPositionServer.GetDefaultModuleId(aModuleId);
// Prepare itemArray and itemArrayDetails
for(TUint i = 0; i < aModules; i++)
{
if ((iPositionServer.GetModuleInfoByIndex(i,info) == KErrNone) && (info.IsAvailable()))
{
TBuf<200> smallBuffer;
smallBuffer.Zero();
info.GetModuleName(smallBuffer);
itemArray->AppendL(smallBuffer);
TBuf<200> buffer;
buffer.Zero();
info.GetModuleName(buffer);
buffer.Append(_L(" ("));
if (info.DeviceLocation() & TPositionModuleInfo::EDeviceExternal)
buffer.Append(_L("External "));
if (info.DeviceLocation() & TPositionModuleInfo::EDeviceInternal)
buffer.Append(_L("Internal "));
if (info.DeviceLocation() & TPositionModuleInfo::EDeviceUnknown)
buffer.Append(_L("Unknown "));
if (info.TechnologyType()& TPositionModuleInfo::ETechnologyAssisted)
buffer.Append(_L("Assisted "));
if (info.TechnologyType()& TPositionModuleInfo::ETechnologyTerminal)
buffer.Append(_L("GPS, "));
if (info.TechnologyType()& TPositionModuleInfo::ETechnologyNetwork)
buffer.Append(_L("Network, "));
if (info.TechnologyType()& TPositionModuleInfo::ETechnologyUnknown)
buffer.Append(_L("Unknown tech, "));
if (buffer.Mid(buffer.Length()-2, 2).Compare( _L(", ")) == KErrNone)
buffer.Replace(buffer.Length()-2, 2, _L(")"));
if (buffer.Mid(buffer.Length()-1, 1).Compare( _L(" ")) == KErrNone)
buffer.Replace(buffer.Length()-1, 1, _L(")"));
if ( info.ModuleId() == aModuleId)
{
buffer.Append(_L(" [Default]"));
defaultModule=i;
}
itemArrayDetails->AppendL(buffer);
}
}
iPositioner.Close();
iPositionServer.Close();
// Present list of positioning methods
TInt selectIndex;
selectIndex=iPosMethod+1;
HBufC* title = NULL;
title = CEikonEnv::Static()->AllocReadResourceLC(R_TTGP_TBUF32_DIALOG_POSITIONING_TITLE); // Select positioning method:
CAknListQueryDialog* dialog = new (ELeave) CAknListQueryDialog(&selectIndex);
dialog->PrepareLC(R_TTGP_DIALOG_LISTQUERY);
dialog->QueryHeading()->SetTextL(*title);
dialog->SetItemTextArray(itemArray);
dialog->SetOwnershipType(ELbmDoesNotOwnItemArray);
TInt answer = dialog->RunLD();
CleanupStack::PopAndDestroy(); // title
// Check answer
if (answer)
{
if (selectIndex==0) // (Info on all modules)
{
TBuf<1000> aText;
aText.Zero();
for (TInt i=0;i<itemArrayDetails->Count();i++)
{
aText.AppendFormat(_L("%d. "), i+1);
aText.Append(itemArrayDetails->MdcaPoint(i));
if (i<itemArrayDetails->Count()-1)
aText.Append(_L("\n"));
}
HBufC* title = CEikonEnv::Static()->AllocReadResourceLC(R_TTGP_TBUF32_AVAILABLEPOSITIONING_TITLE); // Available modules:
CAknMessageQueryDialog* dialog = new (ELeave) CAknMessageQueryDialog();
CleanupStack::PushL(dialog);
dialog->PrepareLC(R_TTGP_DIALOG_MESSAGEQUERY_OK);
dialog->QueryHeading()->SetTextL(*title);
dialog->SetMessageTextL(aText);
CleanupStack::Pop(); // dialog
dialog->RunLD();
CleanupStack::PopAndDestroy(); // title
}
else
if (selectIndex==1) // Default module
{
if (defaultModule>-1)
{
// Present default module name
HBufC* title = CEikonEnv::Static()->AllocReadResourceLC(R_TTGP_TBUF32_SELECTEDPOSITIONING_TITLE); // Selected module:
CAknMessageQueryDialog* dialog = new (ELeave) CAknMessageQueryDialog();
CleanupStack::PushL(dialog);
dialog->PrepareLC(R_TTGP_DIALOG_MESSAGEQUERY_OK);
dialog->QueryHeading()->SetTextL(*title);
dialog->SetMessageTextL(itemArrayDetails->MdcaPoint(defaultModule));
CleanupStack::Pop(); // dialog
dialog->RunLD();
CleanupStack::PopAndDestroy(); // title
}
iPosMethod=0; // default module selected
C_APPUI->Engine()->Requester()->SetPositioningMethod(iPosMethod);
C_APPUI->Engine()->Requester()->StartL();
}
else
if (selectIndex>1) // Custom selection of the module
{
HBufC* title = CEikonEnv::Static()->AllocReadResourceLC(R_TTGP_TBUF32_SELECTEDPOSITIONING_TITLE); // Selected module:
CAknMessageQueryDialog* dialog = new (ELeave) CAknMessageQueryDialog();
CleanupStack::PushL(dialog);
dialog->PrepareLC(R_TTGP_DIALOG_MESSAGEQUERY_OK);
dialog->QueryHeading()->SetTextL(*title);
dialog->SetMessageTextL(itemArrayDetails->MdcaPoint(selectIndex-2));
CleanupStack::Pop(); // dialog
dialog->RunLD();
CleanupStack::PopAndDestroy(); // title
iPosMethod=selectIndex-1;
C_APPUI->Engine()->Requester()->SetPositioningMethod(iPosMethod);
C_APPUI->Engine()->Requester()->StartL();
}
UpdateListBoxTextL();
}
CleanupStack::PopAndDestroy(); // itemArrayDetails
CleanupStack::PopAndDestroy(); // itemArray
}
//
// Performes the test by connecting to MLFW
// (and makes a number of Location requests if aFullTest is true
//
void DoTestL(TBool aFullTest, TInt aNumberOfRuns, TInt *aResult)
{
RPositionServer posServer;
TInt errorCode = errorCode = posServer.Connect();
if (errorCode != KErrNone)
{
*aResult = KErrCouldNotConnect;
return;
}
CleanupClosePushL(posServer);
RPositioner positioner;
// Full test means requesting position updates
if (aFullTest)
{
TPositionInfo positionInfo = TPositionInfo();
const TInt32 KUidMultiPsy = 0x01010176;
TUid uidMultiPsy;
uidMultiPsy.iUid = KUidMultiPsy;
errorCode = positioner.Open(posServer, uidMultiPsy);
if (errorCode != KErrNone)
{
*aResult = errorCode;
return;
}
CleanupClosePushL(positioner);
_LIT(KService ,"Service");
errorCode = positioner.SetRequestor(CRequestor::ERequestorService,
CRequestor::EFormatApplication, KService);
if (errorCode != KErrNone)
{
*aResult = 1001;
return;
}
TRequestStatus status;
TLocality loca(TCoordinate(0,0,0),0);
TPosition pos(loca, TTime(0));
for (TInt i = 0; i < aNumberOfRuns; i++)
{
positionInfo.SetPosition(pos);
positioner.NotifyPositionUpdate(positionInfo, status);
User::WaitForRequest(status);
TInt err = status.Int();
if (err != KErrNone)
{
*aResult = err;
}
TPosition result;
positionInfo.GetPosition(result);
//sanity check
if (result.Latitude() == pos.Latitude() ||
result.Longitude() == pos.Longitude() ||
result.Altitude() == pos.Altitude())
{
//_LIT(KErrorPositon, "ERROR:: The postion was not updated");
errorCode = 1005;
}
}
positioner.Close();
CleanupStack::PopAndDestroy(&positioner);
}
posServer.Close();
CleanupStack::PopAndDestroy(&posServer);
}
