// ----------------------------------------------------------------------------- // 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); } } }