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);)
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;
}
// ---------------------------------------------------------
// 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();
}
TVerdict CPsyDisabledStep::doTestStepL()
/**
* @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.
*/
{
StandardPrepareL();
InitPsySettingsL(3, KNetworkPsy1, 1, KIntGpsPsy1, 1, KNetworkPsy2, 1);
ConfigPsyL(KNetworkPsy1, 1,
KConfigLRNoError10s //Step1. no error in 10s
);
ConfigPsyL(KIntGpsPsy1, 2,
KConfigLRNoError, //Step 1. no error
KConfigLRNoError10s //Step 2. no error in 10s
);
ConfigPsyL(KNetworkPsy2, 1,
KConfigLRNoError //Step2. no error
);
User::After(KSecond*7);
TRequestStatus status;
TPositionInfo posInfo;
TPositionUpdateOptions options;
//1. Disable PSY1 while location request is on going. LR shall
//fallback to PSY2 and then fix from PSY2 is used.
iPositioner.NotifyPositionUpdate(posInfo, status);
User::After(KTinyDelay);
SET_TIME
ToggleModuleL(KNetworkPsy1, EFalse);
User::WaitForRequest(status);
//CHECK_TIME(1)
CheckExpectedResult(status.Int(), KErrNone, KFailedPositionRequest);
CheckExpectedResult(posInfo.ModuleId(), KIntGpsPsy1, KWrongModuleIdReturned);
ToggleModuleL(KNetworkPsy1, ETrue);
//Config PSY1 again since it was unloaded when it was disabled.
ConfigPsyL(KNetworkPsy1, 1,
KConfigLRNoError20s //Step2. no error in 20s
);
User::After(KSecond*7);
//2. Disable PSY2 while location request ongoing, the request shall
//fallbck to PSY3
SET_TIME
iPositioner.NotifyPositionUpdate(posInfo, status);
User::After(KSecond*15); //after 15s disable PSY2
ToggleModuleL(KIntGpsPsy1, EFalse);
User::WaitForRequest(status);
CHECK_TIME(16) //After PSY2 is disabled in 15 seconds, PSY3 is used.
CheckExpectedResult(status.Int(), KErrNone, KFailedPositionRequest);
CheckExpectedResult(posInfo.ModuleId(), KNetworkPsy2, KWrongModuleIdReturned);
// cleanup
StandardCleanup();
return TestStepResult();
}
TVerdict CPsyVisibleStep::doTestStepL()
/**
* @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.
*/
{
StandardPrepareL();
InitPsySettingsL(3, KNetworkPsy1, 1, KIntGpsPsy1, 1, KNetworkPsy2, 1);
ConfigPsyL(KIntGpsPsy1, 3,
KConfigLRNoError5s, //Step 1. no error in 5s
KConfigLRErrGeneral1s, //Step 2. error in 1s
KConfigLRErrGeneral1s //Step 3. error in 1s
);
User::After(KSecond*7);
TRequestStatus status;
TPositionInfo posInfo;
TPositionUpdateOptions options;
ToggleModuleVisibleL(KNetworkPsy1, EFalse);
//1. Set PSY1 visible shall not affect location request
SET_TIME
iPositioner.NotifyPositionUpdate(posInfo, status);
User::After(KTinyDelay);
ToggleModuleVisibleL(KNetworkPsy1, ETrue);
User::WaitForRequest(status);
CHECK_TIME(5)
CheckExpectedResult(status.Int(), KErrNone, KFailedPositionRequest);
CheckExpectedResult(posInfo.ModuleId(), KIntGpsPsy1, KWrongModuleIdReturned);
ToggleModuleVisibleL(KNetworkPsy2, EFalse);
ConfigPsyL(KNetworkPsy1, 2,
KConfigLRNoError35s, //Step2. no error in 35s
KConfigLRErrNoMemory //Step 3. error in 1s
);
User::After(KSecond*7);
//2. Set PSY3 visible during fallback shall has no effect
SET_TIME
iPositioner.NotifyPositionUpdate(posInfo, status);
User::After(KSecond*5);
ToggleModuleVisibleL(KNetworkPsy2, ETrue);
User::WaitForRequest(status);
CHECK_TIME(35) //PSY1 response time
CheckExpectedResult(status.Int(), KErrNone, KFailedPositionRequest);
CheckExpectedResult(posInfo.ModuleId(), KNetworkPsy1, KWrongModuleIdReturned);
//3. PSY3 shall be used in next LR
SET_TIME
iPositioner.NotifyPositionUpdate(posInfo, status);
User::WaitForRequest(status);
CheckExpectedResult(status.Int(), KErrNone, KFailedPositionRequest);
CheckExpectedResult(posInfo.ModuleId(), KNetworkPsy2, KWrongModuleIdReturned);
// cleanup
StandardCleanup();
return TestStepResult();
}
