// -----------------------------------------------------------------------------
// PosGenericInfoUser::CopyHGenericInfo
// -----------------------------------------------------------------------------
//
TInt PosGenericInfoUser::CopyHGenericInfo(
const HPositionGenericInfo& aSrc,
HPositionGenericInfo& aDes )
{
//TRACESTRING( "PosGenericInfoUser::CopyHGenericInfo start" )
//TRACEHEX2( reinterpret_cast < const TUint8* >( &aSrc ), aSrc.PositionClassSize() )
//Set position
TPosition position;
aSrc.GetPosition( position );
aDes.SetPosition( position );
TInt err( KErrNone );
TInt fieldId = aDes.FirstRequestedFieldId();
while ( fieldId != EPositionFieldNone )
{
//TRACESTRING2( "FieldId=%d", fieldId )
if ( aSrc.IsFieldAvailable( fieldId ) )
{
err = CopyField( aSrc, aDes, fieldId );
if ( err != KErrNone )
{
return err;
}
}
fieldId = aDes.NextRequestedFieldId( fieldId );
}
//TRACESTRING( "PosGenericInfoUser::CopyHGenericInfo end" )
return err;
}
// -----------------------------------------------------------------------------
// PosGenericInfoUser::CopyData
// -----------------------------------------------------------------------------
//
template < class T > TInt PosGenericInfoUser::CopyData(
const HPositionGenericInfo& aSrc,
HPositionGenericInfo& aDes,
TInt aFieldId )
{
T data;
TInt err( KErrNone );
err = aSrc.GetValue( aFieldId, data );
if ( err != KErrNone )
{
return err;
}
return aDes.SetValue( aFieldId, data );
}
// -----------------------------------------------------------------------------
// CSuplPsyRequestor::ConstructGenericInfoL
// -----------------------------------------------------------------------------
//
HPositionGenericInfo* CSuplPsyRequestor::ConstructGenericInfoL(
TInt aBufferSize ) const
{
HPositionGenericInfo* positionInfo = HPositionGenericInfo::NewL( aBufferSize );
//Set all requested fields
TInt count = SuplPsyGenericInfoUser::SupportedFieldsCount();
for ( TInt i = 0; i < count; i++ )
{
positionInfo->SetRequestedField(
SuplPsyGenericInfoUser::SupportedFieldAt( i ) );
}
return positionInfo;
}
void CLcfPsyDummy1::GetGenericPositionInfoL(TPositionInfoBase& aPosInfo)
{
_LIT(KStreetDescriptor, "Tieteenkatu 1");
_LIT(KCityDescriptor, "Tampere");
_LIT(KCountryDescriptor, "Finland");
// The position info object is at least a
// HPositionGenericInfo
HPositionGenericInfo* posInfo =
static_cast<HPositionGenericInfo*>(&aPosInfo);
// This PSY can deliver street, city and country
// information. Attach this data if it is requested by
// the client
if (posInfo->IsRequestedField(EPositionFieldStreet))
{
User::LeaveIfError(posInfo->SetValue(
EPositionFieldStreet, KStreetDescriptor));
}
if (posInfo->IsRequestedField(EPositionFieldCity))
{
User::LeaveIfError(posInfo->SetValue(
EPositionFieldCity, KCityDescriptor));
}
if (posInfo->IsRequestedField(EPositionFieldCountry))
{
User::LeaveIfError(posInfo->SetValue(
EPositionFieldCountry, KCountryDescriptor));
}
}
void CLcfPsyDummy1::GetPositionInfoL(TPositionInfoBase& aPosInfo)
{
// check that requested class is supported
if (aPosInfo.PositionClassType() &
~(EPositionInfoClass|
EPositionGenericInfoClass))
{
// some more bits are set
User::RequestComplete(iStatusPtr, KErrArgument);
return;
}
// PSY Tester bug fix: First of all clear HPositionGenericInfo fields,
// if the parameter was of type HPositionGenericInfo
if (aPosInfo.PositionClassType() &
EPositionGenericInfoClass) // was EPositionClassInfo
{
HPositionGenericInfo* posInfo =
static_cast<HPositionGenericInfo*>(&aPosInfo);
// Clear old data
posInfo->ClearPositionData();
}
// Check which position information has been requested
// and provide that information.
if (aPosInfo.PositionClassType() &
EPositionInfoClass) // was EPositionClassInfo
{
GetBasicPositionInfoL(aPosInfo);
}
if (aPosInfo.PositionClassType() &
EPositionGenericInfoClass) // was EPositionClassInfo
{
GetGenericPositionInfoL(aPosInfo);
}
// Complete the request
User::RequestComplete(iStatusPtr, KErrNone);
}
// -----------------------------------------------------------------------------
// PosGenericInfoUser::CopyField
// -----------------------------------------------------------------------------
//
TInt PosGenericInfoUser::CopyField(
const HPositionGenericInfo& aSrc,
HPositionGenericInfo& aDes,
TInt aFieldId )
{
//Get field data type
TInt dataType;
TBool isList;
TInt err( KErrNone );
err = FieldDataType( aFieldId, dataType, isList );
if ( err != KErrNone )
{
return err;
}
if ( isList )
{
//copy list
TUint8 count; //length of the list
err = aSrc.GetValue( aFieldId, count );
if ( err != KErrNone )
{
return err;
}
for ( TInt i = 0; i < count; i++ )
{
err = CopyDataByType( aSrc, aDes, aFieldId + 1 + i, dataType );
if ( err != KErrNone )
{
return err;
}
}
err = aDes.SetValue( aFieldId, count );
}
else
{
err = CopyDataByType( aSrc, aDes, aFieldId, dataType );
}
return err;
}
void CNetworkPsy2::ConfigPsyL(const HPositionGenericInfo& aGenInfo)
{
TInt32 configUid;
User::LeaveIfError(aGenInfo.GetValue(KIntGpsPsy1ConfigPsyUid, configUid));
if(configUid!=iUid.iUid)
{
User::Leave(KErrNotSupported);
}
iPsyConfigArray.Reset();
iCurrentIndex = 0;
TInt32 numOfItem;
User::LeaveIfError(aGenInfo.GetValue(KIntGpsPsy1ConfigItemsNumber, numOfItem));
for(TInt i=0; i<numOfItem; i++)
{
TPsyConfig psyConfig;
TPckg<TPsyConfig> configBuf(psyConfig);
User::LeaveIfError(aGenInfo.GetValue(KIntGpsPsy1ConfigItemsNumber+i+1, configBuf));
User::LeaveIfError(iPsyConfigArray.Append(psyConfig));
}
}
void CNetworkPsy2::NotifyPositionUpdate(
TPositionInfoBase& aPosInfo,
TRequestStatus& aStatus)
{
iRequestStatus = &aStatus;
iPositionInfoBase = &aPosInfo;
if(aPosInfo.PositionClassType() & EPositionGenericInfoClass)
{
//Check if this is confiuration request
HPositionGenericInfo* genInfo =
static_cast<HPositionGenericInfo*>(&aPosInfo);
if(genInfo->IsRequestedField(KIntGpsPsy1ConfigItemsNumber))
{
//Config PSY
TRAPD(err, ConfigPsyL(*genInfo));
CompleteRequest(err);
StartTimerIfNeeded();
return;
}
}
StartTimerIfNeeded();
}
// ---------------------------------------------------------
// CPosPSYClearPositionDataTest::SetHPositionGenericInfoDataL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosPSYClearPositionDataTest::SetHPositionGenericInfoDataL(
HPositionGenericInfo& aGenericInfo)
{
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldCountry,
KCountry));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldCountryCode,
KCountryCode));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldState,
KState));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldCity,
KCity));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldDistrict,
KDistrict));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldStreet,
KStreet));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldStreetExtension,
KStreetExtension));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldLocationName,
KLocationName));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldPostalCode,
KPostalCode));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldLocality,
KLocality));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldCrossing1,
KCrossing1));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldCrossing2,
KCrossing2));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldHorizontalSpeed,
KHorizontalSpeed));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldHorizontalSpeedError,
KHorizontalSpeedError ));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldVerticalSpeedError,
KVerticalSpeedError));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldVerticalSpeed,
KVerticalSpeed));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldHeading,
KHeading));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldHeadingError,
KHeadingError));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldTrueCourse,
KTrueCourse));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldTrueCourseError,
KTrueCourseError));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldMagneticCourse,
KMagneticCourse));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldBuildingName,
KBuildingName));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldBuildingFloor,
KBuildingFloor));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldBuildingRoom,
KBuildingRoom));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldBuildingZone,
KBuildingZone));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldBuildingTelephone,
KBuildingTelephone));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldNMEASentences,
KNMEASentences));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldNMEASentencesStart,
KNMEASentencesStart));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatelliteNumInView,
KSatelliteNumInView));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatelliteNumUsed,
KSatelliteNumUsed));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatelliteTime,
KSatelliteTime));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatelliteHorizontalDoP,
KSatelliteHorizontalDoP));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatelliteVerticalDoP,
KSatelliteVerticalDoP));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatelliteTimeDoP,
KSatelliteTimeDoP));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatellitePositionDoP,
KSatellitePositionDoP));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatelliteSeaLevelAltitude,
KSatelliteSeaLevelAltitude));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldSatelliteGeoidalSeparation,
KSatelliteGeoidalSeparation));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldMediaLinks,
KMediaLinks));
User::LeaveIfError(aGenericInfo.SetValue(EPositionFieldMediaLinksStart,
KMediaLinksStart));
}
// ---------------------------------------------------------
// CPosPSYClearPositionDataTest::CheckGenericInfoClearsL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosPSYClearPositionDataTest::CheckGenericInfoClearsL()
{
TBuf<KClearPositionDataBufSize> buf;
TReal32 real32Num(0);
TInt8 shortNum(0);
TTime time(0);
TUint8 unsignedShortNum(0);
HPositionGenericInfo* genInfo = static_cast<HPositionGenericInfo*> (iPosInfo);
if (genInfo->GetValue(EPositionFieldCountry, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldCountryCode, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldState, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldCity, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldDistrict, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldStreet, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldStreetExtension, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldLocationName, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldPostalCode, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldLocality, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldCrossing1, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldCrossing2, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldHorizontalSpeed, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldHorizontalSpeedError, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldVerticalSpeedError, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldVerticalSpeed, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldHeading, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldHeadingError, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldTrueCourse, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldTrueCourseError, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldMagneticCourse, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldBuildingName, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldBuildingFloor, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldBuildingRoom, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldBuildingZone, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldBuildingTelephone, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldNMEASentences, unsignedShortNum) != KErrNotFound &&
genInfo->GetValue(EPositionFieldNMEASentencesStart, buf) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatelliteNumInView, shortNum) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatelliteNumUsed, shortNum) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatelliteTime, time) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatelliteHorizontalDoP, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatelliteVerticalDoP, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatelliteTimeDoP, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatellitePositionDoP, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatelliteSeaLevelAltitude, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldSatelliteGeoidalSeparation, real32Num) != KErrNotFound &&
genInfo->GetValue(EPositionFieldMediaLinks, unsignedShortNum) != KErrNotFound &&
genInfo->GetValue(EPositionFieldMediaLinksStart, buf) != KErrNotFound)
{
_LIT(KError, "All HPositionGenericInfo fields were not cleared for HPositionGenericInfo.");
AddTestResultL(KError, EErrorMessage);
}
else
{
_LIT(KInfo, "All HPositionGenericInfo fields were cleared for HPositionGenericInfo.");
AddTestResultL(KInfo, EInfoMessage);
}
}
// ---------------------------------------------------------
// CPosPSYClearPositionDataTest::HandlePositionCompleteL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosPSYClearPositionDataTest::HandlePositionCompleteL(
TInt aCompleteCode,
TTimeIntervalMicroSeconds /*aRequestTime*/)
{
if (iTestStatus == KErrCancel)
{
CompleteClearPositionDataTest(iTestStatus);
return;
}
if (iCurrentTestClass == 0 || iCurrentTestClass == EPositionInfoClass)
{
_LIT(KTitleTestInfo, "==== Testing clearing of TPositionInfo ====");
AddTestResultL(KTitleTestInfo, EDisplayMessage);
if (iPSYInfo.ClassesSupported() & EPositionInfoClass &&
!(iClassesTested & EPositionInfoClass))
{
iCurrentTestClass = EPositionInfoClass;
if (iRequestNumber == 0)
{
iClassesTested |= EPositionInfoClass;
PerformTestL(aCompleteCode);
}
}
else
{
_LIT(KTestInfo, "Clearing of position data tests not performed with TPositionInfo because PSY didn't support it.");
AddTestResultL(KTestInfo, EInfoMessage);
}
}
if (iCurrentTestClass == 0 || iCurrentTestClass == EPositionGenericInfoClass)
{
if (iRequestNumber == 0)
{
_LIT(KTestInfoGeneric, "==== Testing clearing of HPositionGenericInfo ====");
AddTestResultL(KTestInfoGeneric, EDisplayMessage);
}
if (iPSYInfo.ClassesSupported() & EPositionGenericInfoClass &&
!(iClassesTested & EPositionGenericInfoClass))
{
iCurrentTestClass = EPositionGenericInfoClass;
if (iRequestNumber == 1)
{
iClassesTested |= EPositionGenericInfoClass;
PerformTestL(aCompleteCode);
}
else
{
HPositionGenericInfo* genInfo = HPositionGenericInfo::NewLC(KPositionGenericInfoDefaultBufferSize * 2,
KPositionGenericInfoDefaultMaxFields * 2);
SetHPositionGenericInfoDataL(*genInfo);
CleanupStack::Pop(genInfo);
genInfo->SetPosition(iPosition);
iPosInfo = static_cast<TPositionInfo*> (genInfo);
iRequester->MakeRequest(*iPosInfo);
iRequestNumber++;
}
}
else
{
_LIT(KTestInfo, "Clearing of position data tests not performed with HPositionGenericInfo because PSY didn't support it.");
AddTestResultL(KTestInfo, EInfoMessage);
}
}
if (iCurrentTestClass == 0 || iCurrentTestClass == EPositionCourseInfoClass)
{
if (iRequestNumber == 0)
{
_LIT(KTestInfo, "==== Testing clearing of TPositionCourseInfo ====");
AddTestResultL(KTestInfo, EDisplayMessage);
}
if (iPSYInfo.ClassesSupported() & EPositionCourseInfoClass &&
!(iClassesTested & EPositionCourseInfoClass))
{
iCurrentTestClass = EPositionCourseInfoClass;
if (iRequestNumber == 1)
{
iClassesTested |= EPositionCourseInfoClass;
PerformTestL(aCompleteCode);
}
else
{
TPositionCourseInfo* courseInfo = new (ELeave) TPositionCourseInfo;
courseInfo->SetCourse(iCourse);
courseInfo->SetPosition(iPosition);
iPosInfo = static_cast<TPositionInfo*> (courseInfo);
iRequester->MakeRequest(*iPosInfo);
iRequestNumber++;
}
}
else
{
_LIT(KTestInfo, "Clearing of position data tests not performed with TPositionCourseInfo because PSY didn't support it.");
AddTestResultL(KTestInfo, EInfoMessage);
}
}
if (iCurrentTestClass == 0 || iCurrentTestClass == EPositionSatelliteInfoClass)
{
if (iRequestNumber == 0)
{
_LIT(KTestInfo, "==== Testing clearing of TPositionSatelliteInfo ====");
AddTestResultL(KTestInfo, EDisplayMessage);
}
if (iPSYInfo.ClassesSupported() & EPositionSatelliteInfoClass &&
!(iClassesTested & EPositionSatelliteInfoClass))
{
iCurrentTestClass = EPositionSatelliteInfoClass;
if (iRequestNumber == 1)
{
iClassesTested |= EPositionSatelliteInfoClass;
PerformTestL(aCompleteCode);
}
else
{
TPositionSatelliteInfo* satInfo = new (ELeave) TPositionSatelliteInfo;
satInfo->SetSatelliteTime(KSatelliteTime);
satInfo->SetHorizontalDoP(KSatelliteHorizontalDoP);
satInfo->SetVerticalDoP(KSatelliteVerticalDoP);
satInfo->SetTimeDoP(KSatelliteTimeDoP);
for (TInt i = 0; i < KSatelliteNumInView; i++)
{
TSatelliteData satellite;
satellite.SetSatelliteId(KSatelliteId+i);
satellite.SetAzimuth(KAzimuth);
satellite.SetElevation(KElevation);
satellite.SetIsUsed(KIsUsed);
satellite.SetSignalStrength(KSignalStrength);
satInfo->AppendSatelliteData(satellite);
}
satInfo->SetCourse(iCourse);
satInfo->SetPosition(iPosition);
iPosInfo = static_cast<TPositionInfo*> (satInfo);
iRequester->MakeRequest(*iPosInfo);
iRequestNumber++;
}
}
else
{
_LIT(KTestInfo, "Clearing of position data tests not performed with TPositionSatelliteInfo because PSY didn't support it.");
AddTestResultL(KTestInfo, EInfoMessage);
}
}
}
TVerdict CTrackingSessionStep::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();
const TInt KInterval = 1 * KSecondsToMicro;
const TTimeIntervalMicroSeconds KFirstRequestDelay = 200 * 1000; // 0.2 sec
const TTimeIntervalMicroSeconds KNormalRequestDelay = 200 * 1000; // 0.2 sec
const TInt KDiff = 200 * 1000; // 0.2 sec
const TInt KIntervalError = 100 * 1000; // 0.1 sec
TRequestStatus status;
TWatch watch;
TTime secondRequest, stopTracking;
TInt interval;
HPositionGenericInfo* genInfo = HPositionGenericInfo::NewLC();
// setup : only PSY6
ToggleModuleL(KUidLcfPsy1, EFalse);
ToggleModuleL(KUidLcfPsy3, EFalse);
User::After(KSecond * 7);
InitPsyListInDefaultProxyL();
// make one request to allow default proxy rebuild its database
// this will guarantee that first request will be as fast as possible
TPositionCourseInfo courseInfo;
PositionRequestWithCheck(courseInfo, KErrArgument, KNullUid);
// setup tracking session
TPositionUpdateOptions updateOptions;
updateOptions.SetUpdateInterval(KInterval);
iPositioner.SetUpdateOptions(updateOptions);
// 1st request
// first request must be quick
watch.Tick();
PositionRequestWithCheck(*genInfo, KErrNone, KUidLcfPsy6);
if(watch.ElapsedFromTick() > KFirstRequestDelay)
{
ERR_PRINTF1(KFirstDelayTooLong);
SetTestStepResult(EFail);
}
// drop delay and make 2nd and 3rd requests
genInfo->ClearRequestedFields();
{
watch.Tick();
PositionRequestWithCheck(*genInfo, KErrNone, KUidLcfPsy6);
secondRequest.UniversalTime();
interval = (TInt) watch.ElapsedFromTick().Int64();
if(Abs(interval - KInterval) > KIntervalError)
{
ERR_PRINTF1(KSecondDelayOutOfRange);
SetTestStepResult(EFail);
}
watch.Tick();
PositionRequestWithCheck(*genInfo, KErrNone, KUidLcfPsy6);
interval = watch.ElapsedFromTick().Int64();
if(Abs(interval - KInterval) > KIntervalError)
{
ERR_PRINTF1(KThirdDelayOutOfRange);
SetTestStepResult(EFail);
}
}
// stop tracking
updateOptions.SetUpdateInterval(TTimeIntervalMicroSeconds(0));
iPositioner.SetUpdateOptions(updateOptions);
stopTracking.UniversalTime();
// psy6 must return event log
genInfo->SetRequestedField(KPSY6FieldEventLog);
watch.Tick();
PositionRequestWithCheck(*genInfo, KErrNone, KUidLcfPsy6);
if(watch.ElapsedFromTick() > KNormalRequestDelay)
{
ERR_PRINTF1(KNormalDelayTooBig);
SetTestStepResult(EFail);
}
// Analyze event log from PSY6
TQueryEvent* eventArray = GetPsy6EventLogL(*genInfo);
TInt32 logSize;
if(KErrNone != genInfo->GetValue(KPSY6FieldEventLogSize, logSize))
{
ERR_PRINTF1(KFailedReadLogsize);
SetTestStepResult(EFail);
return TestStepResult();
}
TUint expectedEvents[] = {EUpdate,
ETrackingStart,
EUpdate,
EUpdate,
ETrackingStop,
EUpdate};
TUint numExpectedEvents = sizeof(expectedEvents) / sizeof(TUint);
CheckExpectedResult(logSize, numExpectedEvents, KWrongEventNumberPSY6);
// check event types
for (TInt32 index = 0; index < Min(logSize, numExpectedEvents); index++)
{
TQueryEvent& event = *(eventArray + index);
CheckExpectedResult(event.iEventType, expectedEvents[index], KUnexpectedEvent);
}
// check event times
if(logSize != numExpectedEvents)
{
ERR_PRINTF1(KCannotCheckEventTimes);
SetTestStepResult(EFail);
return TestStepResult();
}
// ( ETrackingStart should have happenned right after first
// request was completed )
// Harley: Because of intelligent Default Proxy change, the tracking start
// shall happen just before the second location request is issued to the PSY.
TQueryEvent& event = *(eventArray + 1);
if(Abs(secondRequest.MicroSecondsFrom(event.iTime).Int64()) > KDiff)
{
ERR_PRINTF1(KStartEventBeyondExpectendRange);
SetTestStepResult(EFail);
}
// ETrackingStop should have happenned right after second
// SetUpdateOptions
event = *(eventArray + 4);
if(Abs(stopTracking.MicroSecondsFrom(event.iTime).Int64()) > KDiff)
{
ERR_PRINTF1(KStopEventBeyondExpectendRange);
SetTestStepResult(EFail);
}
// cleanup
CleanupStack::PopAndDestroy(genInfo);
StandardCleanup();
return TestStepResult();
}
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();
}
void PsyUtils::TPositionInfo2QGeoPositionInfo(TPositionInfoBase &aPosInfoBase, QGeoPositionInfo& aQPosInfo)
{
if (aPosInfoBase.PositionClassType() & EPositionInfoClass ||
aPosInfoBase.PositionClassType() & EPositionSatelliteInfoClass) {
TPositionInfo *posInfo = static_cast<TPositionInfo*>(&aPosInfoBase);
TPosition pos;
QGeoCoordinate coord;
posInfo->GetPosition(pos);
coord.setLatitude(pos.Latitude());
coord.setLongitude(pos.Longitude());
coord.setAltitude(pos.Altitude());
//store the QGeoCoordinate values
aQPosInfo.setCoordinate(coord);
TDateTime datetime = pos.Time().DateTime();
QDateTime dt(QDate(datetime.Year() , datetime.Month() + 1, datetime.Day() + 1),
QTime(datetime.Hour() , datetime.Minute(), datetime.Second(),
datetime.MicroSecond() / 1000),
Qt::UTC);
//store the time stamp
aQPosInfo.setTimestamp(dt);
//store the horizontal accuracy
aQPosInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy, pos.HorizontalAccuracy());
//store the vertical accuracy
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy, pos.VerticalAccuracy());
if (aPosInfoBase.PositionClassType() & EPositionSatelliteInfoClass) {
TCourse course;
TPositionSatelliteInfo *satInfo = static_cast<TPositionSatelliteInfo*>(&aPosInfoBase);
satInfo->GetCourse(course);
aQPosInfo.setAttribute(QGeoPositionInfo::Direction, course.Heading());
aQPosInfo.setAttribute(QGeoPositionInfo::GroundSpeed, course.Speed());
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, course.VerticalSpeed());
}
}
if (aPosInfoBase.PositionClassType() & EPositionGenericInfoClass) {
HPositionGenericInfo *genInfo = static_cast<HPositionGenericInfo*>(&aPosInfoBase);
float val;
//check for the horizontal speed
if (genInfo->IsFieldAvailable(EPositionFieldHorizontalSpeed)) {
genInfo->GetValue(EPositionFieldHorizontalSpeed, val);
aQPosInfo.setAttribute(QGeoPositionInfo::GroundSpeed, val);
}
//check for the vertcal speed
if (genInfo->IsFieldAvailable(EPositionFieldVerticalSpeed)) {
genInfo->GetValue(EPositionFieldVerticalSpeed, val);
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, val);
}
//check for the magnetic variation
if (genInfo->IsFieldAvailable(EPositionFieldMagneticCourseError)) {
genInfo->GetValue(EPositionFieldMagneticCourseError, val);
aQPosInfo.setAttribute(QGeoPositionInfo::MagneticVariation, val);
}
//check for the heading
if (genInfo->IsFieldAvailable(EPositionFieldHeading)) {
genInfo->GetValue(EPositionFieldHeading, val);
aQPosInfo.setAttribute(QGeoPositionInfo::Direction, val);
}
}
}
