void CT_LbsClientPosTp2::RequestL(TPositionInfoBase& aInfoBase)
{
_LIT(KService, "service");
TInt err = PerformSyncRequest(KService, &aInfoBase);
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrorNone, errCode = %d");
TBuf<100> buf;
buf.Format(KErrorRequest, err);
LogErrorAndLeaveL(buf);
}
_LIT(KIncorrectPsySyncRequestError,
"TP2. Position from wrong PSY received (sync request).");
AssertTrueL(iUidMultiPsy == aInfoBase.ModuleId(), KIncorrectPsySyncRequestError);
}
// ---------------------------------------------------------
// 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();
}
/*
* Make two client sessions. First client request position and waits for time of aDelay.
* Next set Max Update Age of second client and issue position request of second client.
* If aLatitudeDiff and aLongitudeDiff parameters are set method will use them to
* return calculated difference of client positions.
* @param aIsSps set to ETrue if function should use SPS simulation mode, EFalse for NMEA simulation mode.
* @param aSecondClientDelay is delay in milliseconds of second positioner request.
* @param aMaxUpdateAge value in milliseconds that will be set to Max Update Age option of second positioner.
* @param aLatitudeDiff this parameter will store difference of latitude between clients position.
* @param aLongitudeDiff this parameter will store difference of longitude between clients position.
* @return ETrue if clients positions are equal. Otherwise EFalse.
*/
TBool CT_LbsSimulationPsyPosTp400::TwoClientRequestL(TBool aIsSps,
TInt aSecondClientDelay, TInt aMaxUpdateAge, TReal* aLatitudeDiff,
TReal* aLongitudeDiff)
{
_LIT(KErrorRequestingPosition, "Position Request Error.");
_LIT(KGetUpdateOptionsErr, "Error %d when getting update options.");
_LIT(KSetUpdateOptionsErr, "Error %d when setting Max Update Age option.");
#ifdef __WINS__
_LIT(KTrpNmeaFile, "z:\\system\\test\\testdata\\trpnmeadatafile.nme");
_LIT(KTrpSpsFile, "z:\\system\\test\\testdata\\trpspsdatafile.sps");
#else
_LIT(KTrpNmeaFile, "c:\\system\\test\\testdata\\trpnmeadatafile.nme");
_LIT(KTrpSpsFile, "c:\\system\\test\\testdata\\trpspsdatafile.sps");
#endif
iOldTrpMode = TrpModeL();
SetTrpModeL(KTrpModeEnable);
//Creating client subsessions to position server.
RPositioner positioner1;
RPositioner positioner2;
if (aIsSps)
{
OpenNewSourceFileLC(KTrpSpsFile, positioner1);
OpenNewSourceFileLC(KTrpSpsFile, positioner2);
}
else
{
OpenNewSourceFileLC(KTrpNmeaFile, positioner1);
OpenNewSourceFileLC(KTrpNmeaFile, positioner2);
}
//Seting Max Update Age option for second Positioner.
TPositionUpdateOptions posOption;
TInt err = positioner2.GetUpdateOptions(posOption);
AssertTrueL(err == KErrNone, KGetUpdateOptionsErr, err);
posOption.SetMaxUpdateAge(aMaxUpdateAge);
err = positioner2.SetUpdateOptions(posOption);
AssertTrueL(err == KErrNone, KSetUpdateOptionsErr, err);
TPositionInfo fix1;
TPositionInfo fix2;
//Position request of First client.
err = PerformSyncRequest(fix1, positioner1);
AssertTrueL(err == KErrNone, KErrorRequestingPosition, err);
//Delay of second positioner.
User::After(aSecondClientDelay);
//Position request of Second client.
err = PerformSyncRequest(fix2, positioner2);
AssertTrueL(err == KErrNone, KErrorRequestingPosition, err);
//Getting fixed positions.
TPosition pos1;
fix1.GetPosition(pos1);
TPosition pos2;
fix2.GetPosition(pos2);
//Closing positioners
CleanupStack::PopAndDestroy(&positioner2);
CleanupStack::PopAndDestroy(&positioner1);
//Seting longitude and latitude difference.
if (aLatitudeDiff != NULL)
{
*aLatitudeDiff = pos2.Latitude() - pos1.Latitude();
}
if (aLongitudeDiff != NULL)
{
*aLongitudeDiff = pos2.Longitude() - pos1.Longitude();
}
return pos1.Latitude() == pos2.Latitude() && pos1.Longitude() == pos2.Longitude();
}
// ---------------------------------------------------------
// CT_LbsClientPosTp178::TestTimeout
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp178::TestTimeoutL()
{
_LIT(KSTART, "TestTimeout()");
_LIT(KEND, "TestTimeout() passed");
_LIT(KTIME, "Request took %d us");
// Setup verification stuff
INFO_PRINTF1(KSTART);
//TPrivDlgDiagnostics tmpdiag;
TTime requestStartTime;
TTime requestStopTime;
TTimeIntervalMicroSeconds durationMicro;
TBuf<100> buf;
_LIT(KService, "SAAA");
TPositionUpdateOptions updateOptions;
TTimeIntervalMicroSeconds longInterval(7000000);
ConnectL();
SetupPsyL(iUidTestPsy3);
OpenPositionerByName(iUidTestPsy3);
updateOptions.SetUpdateTimeOut(longInterval);
// Access protected member (iPositioner) here
iPositioner.SetUpdateOptions(updateOptions);
_LIT(KONE, "Perform first request, should NOT time out");
INFO_PRINTF1(KONE);
requestStartTime.UniversalTime();
//Make one request to verify psy
PerformRequestL(KService, CRequestor::ERequestorService, CRequestor::EFormatApplication);
CheckRequestResultL(KErrNone);
requestStopTime.UniversalTime();
durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime);
TInt duration = durationMicro.Int64();
buf.Format(KTIME, duration);
INFO_PRINTF1(buf);
ClosePositioner();
OpenPositionerByName(iUidTestPsy3);
// ECancelButton means that the Automatised class should wait for a cancel call
// before returning result
updateOptions.SetUpdateTimeOut(longInterval);
// Access protected (iPositioner) member here
iPositioner.SetUpdateOptions(updateOptions);
_LIT(KTWO, "Perform second request, should not time out");
INFO_PRINTF1(KTWO);
//Make one request to verify psy
TPositionInfo info = TPositionInfo();
requestStartTime.UniversalTime();
TInt err = PerformSyncRequest(KService, &info);
requestStopTime.UniversalTime();
if (err != KErrNone)
{
_LIT(KError, "Wrong result from iStatus, should be KErrNone, was %d");
TBuf<100> buf;
buf.Format(KError, err);
LogErrorAndLeaveL(buf);
}
durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime);
duration = durationMicro.Int64();
buf.Format(KTIME, duration);
INFO_PRINTF1(buf);
ClosePositioner();
Disconnect();
INFO_PRINTF1(KEND);
}
