/* * Set new source file in central repository and open new RPositioner session. * Opened session will be left on cleanup stack. * @param aName Name of file to set in central repository. * @param aPositioner reference to constructed but unopened RPositioner that will use data from this particular file. * This parameter will opened and the session will be left on cleanup stack. */ void CT_LbsSimulationPsyPosTp400::OpenNewSourceFileLC(const TDesC& aName, RPositioner& aPositioner) { _LIT(KOpenPositionerErr, "Error when opening positioner, %d"); _LIT(KSettingRequestorErr, "Error when setting requester, %d"); TInt err = KErrNone; SetSimDataFileL(aName); err = aPositioner.Open(iPosServer, iUidSimulationPsy); AssertTrueL(err == KErrNone, KOpenPositionerErr, err); CleanupClosePushL(aPositioner); _LIT(KService, "service"); err = aPositioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KService); AssertTrueL(err == KErrNone, KSettingRequestorErr, err); }
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); }
void CT_LbsClientPosTp178::TestOptionL() { SetupPsyL(iUidTestPsy3); RPositioner positioner; ConnectL(); User::LeaveIfError(positioner.Open(iPosServer,iUidTestPsy3)); CleanupClosePushL(positioner); _LIT(KKalle, "Kalle"); positioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KKalle); TPositionUpdateOptions updateOptions; TTimeIntervalMicroSeconds timeoutInterval(4000000); TTimeIntervalMicroSeconds periodicInterval(7000000); updateOptions.SetUpdateTimeOut(timeoutInterval); updateOptions.SetUpdateInterval(periodicInterval); TInt err = positioner.SetUpdateOptions(updateOptions); if (err != KErrArgument) { _LIT(KErrArg, "Possible to set timout < update interval, error code = %d"); TBuf<100> buf; buf.Format(KErrArg, err); INFO_PRINTF1(buf); LogErrorAndLeaveL(buf); } //should never be runned; CleanupStack::PopAndDestroy(1); //positioner Disconnect(); }
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(); }
TVerdict CGetFixTestStep::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(); RPositionServer server; if(KErrNone != server.Connect()) { ERR_PRINTF1(KFailedConnectServer); SetTestStepResult(EFail); return TestStepResult(); } CleanupClosePushL(server); RPositioner positioner; if(KErrNone != positioner.Open(server)) { ERR_PRINTF1(KFailedOpenPositioner); SetTestStepResult(EFail); return TestStepResult(); } CleanupClosePushL(positioner); CheckExpectedResult(KErrNone, SetAuthenticRequestor(positioner)); TPositionInfo posInfo; TRequestStatus reqStatus; // // 1. No modules, no last known fix DisableAllModulesL(); // ask for a fix positioner.NotifyPositionUpdate(posInfo, reqStatus); User::WaitForRequest(reqStatus); CheckExpectedResult(reqStatus.Int(), KErrNotFound, KWrongResult); // ask for last known pos TRequestStatus dbclear; server.EmptyLastKnownPositionStore(dbclear); User::WaitForRequest(dbclear); positioner.GetLastKnownPosition(posInfo, reqStatus); User::WaitForRequest(reqStatus); if (reqStatus.Int() != KErrUnknown) { ERR_PRINTF2(_L("GetLastKnownPosition returned %d"),reqStatus.Int()); SetTestStepResult(EFail); } // // 2. Some modules, last known fix exists // first, create LastKnownPos const TUid KPsy1Uid = {KLcfPsy1UidValue}; TogglePsyL(KPsy1Uid, ETrue); positioner.NotifyPositionUpdate(posInfo, reqStatus); User::WaitForRequest(reqStatus); CheckExpectedResult(reqStatus.Int(), KErrNone, KWrongResult); // now last known pos exists, ask for it positioner.GetLastKnownPosition(posInfo, reqStatus); User::WaitForRequest(reqStatus); CheckExpectedResult(reqStatus.Int(), KErrNone, KWrongResult); // // 3. No modules, last known fix exists TogglePsyL(KPsy1Uid, EFalse); // ask for a fix positioner.NotifyPositionUpdate(posInfo, reqStatus); User::WaitForRequest(reqStatus); CheckExpectedResult(reqStatus.Int(), KErrNotFound, KWrongResult); // now last known pos exists, ask for it positioner.GetLastKnownPosition(posInfo, reqStatus); User::WaitForRequest(reqStatus); CheckExpectedResult(reqStatus.Int(), KErrNone, KWrongResult); CleanupStack::PopAndDestroy(2, &server); return TestStepResult(); }
TVerdict CT_LbsHybridUEAssistedMOLRNoGPSUpdate::doTestStepL() { INFO_PRINTF1(_L("CT_LbsHybridUEAssistedMOLRNoGPSUpdate::doTestStepL()")); // Stop the test if the preable failed TESTL(TestStepResult() == EPass); const TInt KTimeOut = 60*1000*1000; // Create Network Protocol Proxy CNetProtocolProxy* proxy = CNetProtocolProxy::NewL(); CleanupStack::PushL(proxy); // waiting for >> AdviceSystemStatus(0) - GetCurrentCapabilitiesResponse INFO_PRINTF1(_L("waiting for << NotifyPositionUpdate()")); TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgGetCurrentCapabilitiesResponse); CLbsNetworkProtocolBase::TLbsSystemStatus status; proxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status); TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone); // >> AdviceSystemStatus(0) - GetCurrentCapabilitiesResponse INFO_PRINTF1(_L("<< NotifyPositionUpdate()")); // Start Test Step RPositionServer server; TESTL(KErrNone == server.Connect()); CleanupClosePushL(server); INFO_PRINTF1(_L("Connected to server")); RPositioner pos; TESTL(KErrNone == pos.Open(server)); CleanupClosePushL(pos); INFO_PRINTF1(_L("Subsession created")); // Set the max fix time for the client request to ensure the location server does not complete the request too soon during the test. // after 30 secs the postion request will be timed out TPositionUpdateOptions posOpts(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(30* 1000 * 1000)); pos.SetUpdateOptions(posOpts); INFO_PRINTF1(_L("Setupdate options timeout set to 30 seconds")); CPosServerWatcher *pWatch = CPosServerWatcher::NewLC(pos, *this); // Request a self-locate MoLr. pWatch->IssueNotifyPositionUpdate(); INFO_PRINTF1(_L("<< NotifyPositionUpdate()")); // >> RequestSelfLocation() TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestSelfLocation); INFO_PRINTF1(_L(">> RequestSelfLocation()")); // Process the response. TLbsNetSessionId* sessionId = NULL; TLbsNetPosRequestOptionsAssistance* opts = NULL; TInt cleanupCnt; cleanupCnt = proxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts); iSessionId.SetSessionNum(sessionId->SessionNum()); iSessionId.SetSessionOwner(sessionId->SessionOwner()); CleanupStack::PopAndDestroy(cleanupCnt); sessionId = NULL; opts = NULL; // << ProcessStatusUpdate(EServiceSelfLocation) MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceSelfLocation; proxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask); // << ProcessLocationUpdate(SessionId, RefPosition) TPositionInfo refPosInfo = ArgUtils::MolrReferencePositionInfo(); proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo); INFO_PRINTF1(_L("<< ProcessLocationUpdate(SessionId, RefPosition)")); // TEST: Get the ref pos app side. CheckForObserverEventTestsL(KTimeOut, *this); // << ProcessAssistanceData() TLbsAsistanceDataGroup dataMask = EAssistanceDataReferenceTime; RLbsAssistanceDataBuilderSet assistanceData; ArgUtils::PopulateLC(assistanceData); TInt reason = KErrNone; proxy->CallL(ENetMsgProcessAssistanceData, &dataMask, &assistanceData, &reason); CleanupStack::PopAndDestroy(); // assistanceData INFO_PRINTF1(_L("<< ProcessAssistanceData()")); // << ProcessLocationRequest(SessionId, HybridMode, alpha2) TBool emergency = EFalse; MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation; TLbsNetPosRequestQuality quality = ArgUtils::Quality(); quality.SetMaxFixTime(ArgUtils::Alpha2()); TLbsNetPosRequestMethod method = ArgUtils::RequestHybridMethod(); proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method); INFO_PRINTF1(_L("<< ProcessLocationRequest(SessionId, HybridMode, alpha2)")); // Now that the hybrid/alpha2 has been requested, record current time to verify alpha2 timer expires correctly. TTime startTime; startTime.HomeTime(); // >> RequestAssistanceData(0) TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); INFO_PRINTF1(_L(">> RequestAssistanceData(0)")); CleanupStack::PopAndDestroy(proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask)); TESTL(dataMask == EAssistanceDataNone); // << NotifyPositionUpdate() pWatch->IssueNotifyPositionUpdate(); INFO_PRINTF1(_L("<< NotifyPositionUpdate()")); // >> RequestAssistanceData(0) TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); CleanupStack::PopAndDestroy(proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask)); TESTL(dataMask == EAssistanceDataNone); INFO_PRINTF1(_L(">> RequestAssistanceData(0)")); // Determine the value to take off the alpha2 value. This is required because we had to wait for the assistance data response. TTimeIntervalMicroSeconds microseconds; TTime stopTime; stopTime.HomeTime(); microseconds = stopTime.MicroSecondsFrom(startTime); TInt64 timeElapsed = microseconds.Int64(); TInt delta = 2 * 1000 * 1000; // 2 secs. // >> RespondLocationRequest() TESTL(proxy->WaitForResponse(ArgUtils::Alpha2() - timeElapsed - delta) == ENetMsgTimeoutExpired); INFO_PRINTF1(_L(">> RespondLocationRequest()")); // Wait for and process the response. TESTL(proxy->WaitForResponse(2 * delta) == ENetMsgRespondLocationRequest); INFO_PRINTF1(_L("Wait for and process the response")); sessionId = NULL; TPositionGpsMeasurementInfo* measurementInfo = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &measurementInfo); TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); TESTL(reason == KErrNone); CleanupStack::PopAndDestroy(cleanupCnt); //sessionId, measurementInfo // Recv -> RequestAssistanceData - we get an extra msg as the result of the A-GPS manager re-issueing a location request when it's // max fix time timer expries. INFO_PRINTF1(_L("Wait for ENetMsgRequestAssistanceData")); TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); INFO_PRINTF1(_L("Got ENetMsgRequestAssistanceData")); proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); const TInt t = 4 * 1000 * 1000; // 4 secs, hybrid A-GPS module will deliver update after 6 + 1 seconds. quality.SetMaxFixTime(t); // << ProcessLocationRequest(SessionId, HybridMode, t) proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method); INFO_PRINTF1(_L("<< ProcessLocationRequest(SessionId, HybridMode, t)")); // >> RequestAssistanceData(0) INFO_PRINTF1(_L("Wait for >> RequestAssistanceData(0) again")); TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); INFO_PRINTF1(_L(">> RequestAssistanceData(0)")); proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); // >> RespondLocationRequest(). TESTL(proxy->WaitForResponse(t + delta) == ENetMsgRespondLocationRequest); INFO_PRINTF1(_L(">> RespondLocationRequest()")); // Process response. Note measurement data is un-defined (and not verified) when reason contains // an error, which is expected here. sessionId = NULL; measurementInfo = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &measurementInfo); TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); TESTL(reason == KErrPositionNoGpsUpdate); CleanupStack::PopAndDestroy(cleanupCnt);// sessionId, measurementInfo/positionInfo // >> RequestAssistanceData - we get an extra msg as the result of the A-GPS manager re-issueing a location request when it's // max fix time timer expries. TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); INFO_PRINTF1(_L(">>> RequestAssistanceData")); proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); // << ProcessSessionComplete(SessionId, KErrNone) reason = KErrNone; proxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason); INFO_PRINTF1(_L("<< ProcessSessionComplete(SessionId, KErrNone)")); // << ENetMsgProcessStatusUpdate() MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask serviceMask = MLbsNetworkProtocolObserver::EServiceNone; proxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask); INFO_PRINTF1(_L("<< ENetMsgProcessStatusUpdate()")); // Wait for the LBS responses due to the Session Complete. NPUD still outstanding so resend // requests for SelfLocation and we may also get a request for Assistance Data. This is timing // related since the PM's SessionComplete is sent to the AGPS Manager and the NRH, and the NRH // then sends a cancel message to the AGPS manager. These events trigger active objects and // both AOs will make a RequestLocationUpdate call to the Int. Module. Another AO in the Int. // module will respond with an assistance data request. However, depending on timing, the 2nd // call to RequestLocationUpdate may cancel the AO set off by the 1st call. Thus we may get 1 // (most likely) or 2 assistance data requests. These will result in a SelfLocation request // always being sent to the PM but sometimes the PM may get a request for Assistance Data. // Some time later (imperically < 20 secs but could be worked out by going through the test code) // the NPUD maxFixTime timer will fire which will cause the SelfLocation request to be cancelled. // Sometimes it can happen that the session complete arrives quickly enough and no // further response is given by LBS. This was seen in SMP. TInt selfLocationCount = 0; TInt assistanceDataCount = 0; TInt cancelCount = 0; TInt othersCount = 0; TBool noResponse(EFalse); TNetProtocolResponseType response = ENetMsgNullResponse; while ((cancelCount == 0) && (othersCount == 0) && !noResponse) { response = proxy->WaitForResponse(20*1000*1000); // wait for a max of 20secs switch (response) { case ENetMsgTimeoutExpired: { noResponse = ETrue; INFO_PRINTF1(_L(">> No further response was received")); break; } case ENetMsgCancelSelfLocation: { cancelCount++; INFO_PRINTF1(_L(">> Wait for CancelSelfLocation")); break; } case ENetMsgRequestSelfLocation: { selfLocationCount++; INFO_PRINTF1(_L(">> Wait for RequestSelfLocation")); break; } case ENetMsgRequestAssistanceData: { assistanceDataCount++; INFO_PRINTF1(_L(">> Wait for RequestAssistanceData")); break; } default: { othersCount++; INFO_PRINTF2(_L(">> Unexpected message %d"), response); break; } } } if(!noResponse) { // these tests should be done only if there was a response received TESTL(othersCount == 0); TESTL(selfLocationCount == 1); TESTL(cancelCount == 1); } CheckForObserverEventTestsL(KTimeOut, *this); // Listen for 10 seconds that there are note further messages TESTL(proxy->WaitForResponse(10*1000*1000) == ENetMsgTimeoutExpired); // Done. Now cleanup... CleanupStack::PopAndDestroy(pWatch); CleanupStack::PopAndDestroy(); // pos CleanupStack::PopAndDestroy(); // server CleanupStack::PopAndDestroy(proxy); INFO_PRINTF1(_L("All DONE!")); return TestStepResult(); }
TVerdict CT_LbsPTAMOLRPartialEarlyComplete::doTestStepL() { INFO_PRINTF1(_L("CT_LbsPTAMOLRPartialEarlyComplete::doTestStepL()")); // Stop the test if the preable failed TESTL(TestStepResult() == EPass); const TInt KTimeOut = 60*1000*1000; // Create Network Protocol Proxy CNetProtocolProxy* proxy = CNetProtocolProxy::NewL(); CleanupStack::PushL(proxy); // >> AdviceSystemStatus(0) - GetCurrentCapabilitiesResponse TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgGetCurrentCapabilitiesResponse); CLbsNetworkProtocolBase::TLbsSystemStatus status; TInt cleanupCnt; cleanupCnt = proxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status); TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone); CleanupStack::PopAndDestroy(cleanupCnt); // Start Actual Test Step RPositionServer server; TESTL(KErrNone == server.Connect()); CleanupClosePushL(server); RPositioner pos; TESTL(KErrNone == pos.Open(server)); CleanupClosePushL(pos); // Set the max fix time for the client request to ensure the location server does not complete the request too soon during the test. TPositionUpdateOptions posOpts(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(KMOLRFixTime), 0 , ETrue); pos.SetUpdateOptions(posOpts); CPosServerWatcher *pWatch = CPosServerWatcher::NewLC(pos, *this); // Client Send: Request a self-locate MoLr. pWatch->IssueNotifyPositionUpdate(); //Recv: RequestSelfLocation() TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestSelfLocation); // Process the response. TLbsNetSessionId* sessionId = NULL; TLbsNetPosRequestOptionsAssistance* opts = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts); TBool qualitycheck = ArgUtils::CompareQuality( opts, ETrue, KMinHorizontalAcc, /* as read from quality profile on z: */ KMinVerticalAcc, KMOLRFixTime, 0, EAssistanceDataReferenceTime, (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted) ); TESTL(qualitycheck); iSessionId.SetSessionNum(sessionId->SessionNum()); iSessionId.SetSessionOwner(sessionId->SessionOwner()); CleanupStack::PopAndDestroy(cleanupCnt); //Send: ProcessStatusUpdate(EServiceSelfLocation) MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceSelfLocation; proxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask); // Client Recv: (KPositionPartialUpdate, GPS Info) // in TAP mode dont get any AGPS psotions! CheckForObserverEventTestsL(KTimeOut, *this); // TESTL(iState == EGpsPartialInitReceived); //Client Send: Notify Position Update // pWatch->IssueNotifyPositionUpdate(); //Recv: RequestAssistanceData(Mask=0) - as result of the second client noitfy update request. TLbsAsistanceDataGroup dataMask; TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); //Client Send: CompleteRequest TESTL(pos.CompleteRequest(EPositionerNotifyPositionUpdate) == KErrNone); // Client Recv: Second Partial update position - This should return with KPositionEarlyComplete CheckForObserverEventTestsL(KTimeOut, *this); TESTL(iState == EGpsPartialEarlyReceived); //Send: ProcessLocationUpdate(SessionId, RefPosition) TPositionInfo refPosInfo = ArgUtils::MolrReferencePositionInfo(); proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo); //Send: ProcessAssistanceData() dataMask = EAssistanceDataReferenceTime; RLbsAssistanceDataBuilderSet assistanceData; ArgUtils::PopulateLC(assistanceData); TInt reason = KErrNone; proxy->CallL(ENetMsgProcessAssistanceData, &dataMask, &assistanceData, &reason); CleanupStack::PopAndDestroy(); //Send: ProcessLocationRequest(SessionId, HybridMode, alpha2) TBool emergency = EFalse; MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation; TLbsNetPosRequestQuality quality = ArgUtils::Quality(); quality.SetMaxFixTime(ArgUtils::Alpha2()); TLbsNetPosRequestMethod method = ArgUtils::RequestHybridMethod(); proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method); //Recv: RequestAssistanceData(Mask=0) TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); //Recv: Wait for and process the response (SessionId=1, KErrNone, GpsPos2) TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRespondLocationRequest); TPositionInfo* positionInfo = NULL; sessionId = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo); TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass)); TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); TESTL(reason == KErrNone); CleanupStack::PopAndDestroy(cleanupCnt); //Send: ProcessLocationUpdate(SessionId, FinalNetworkPosition) TPositionInfo networkPosInfo = ArgUtils::MolrNetworkPositionInfo(); proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &networkPosInfo); //Send: ProcessSessionComplete(SessionId, KErrNone) reason = KErrNone; proxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason); //Send: ENetMsgProcessStatusUpdate() MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask serviceMask = MLbsNetworkProtocolObserver::EServiceNone; proxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask); // Wait for 10 seconds to ensure no additional responses turn up. TInt delta = 10 * 1000 * 1000; TNetProtocolResponseType mType = proxy->WaitForResponse(delta); TESTL(mType == ENetMsgTimeoutExpired); //Done. Now cleanup... CleanupStack::PopAndDestroy(pWatch); CleanupStack::PopAndDestroy(); // pos CleanupStack::PopAndDestroy(); // server CleanupStack::PopAndDestroy(proxy); return TestStepResult(); }
TVerdict CT_LbsX3PIntByMoLr::doTestStepL() { INFO_PRINTF1(_L("CT_LbsX3PIntByMoLr::doTestStepL()")); // Stop the test if the preable failed TESTL(TestStepResult() == EPass); const TInt KTimeOut = 60*1000*1000; // Create Network Protocol Proxy CNetProtocolProxy* proxy = CNetProtocolProxy::NewL(); CleanupStack::PushL(proxy); // >> AdviceSystemStatus(0) - GetCurrentCapabilitiesResponse TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgGetCurrentCapabilitiesResponse); CLbsNetworkProtocolBase::TLbsSystemStatus status; TInt cleanupCnt; cleanupCnt = proxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status); TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone); CleanupStack::PopAndDestroy(cleanupCnt); // Start Test Step RPositionServer server; TESTL(KErrNone == server.Connect()); CleanupClosePushL(server); RPositioner pos; TESTL(KErrNone == pos.Open(server)); CleanupClosePushL(pos); // Set the max fix time for the client request to ensure the location server does not complete the request too soon during the test. TPositionUpdateOptions posOpts(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(240000000)); pos.SetUpdateOptions(posOpts); CPosServerWatcher *pWatch = CPosServerWatcher::NewLC(pos, *this); // Request a self-locate MoLr. pWatch->IssueNotifyPositionUpdate(); // >> RequestSelfLocation() TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestSelfLocation); // Process the response. TLbsNetSessionId* sessionId = NULL; TLbsNetPosRequestOptionsAssistance* opts = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts); iSessionId.SetSessionNum(sessionId->SessionNum()); iSessionId.SetSessionOwner(sessionId->SessionOwner()); CleanupStack::PopAndDestroy(cleanupCnt); sessionId = NULL; opts = NULL; // << ProcessStatusUpdate(EServiceSelfLocation) MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceSelfLocation; proxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask); // << ProcessLocationUpdate(SessionId, RefPosition) TPositionInfo refPosInfo = ArgUtils::MolrReferencePositionInfo(); proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo); // TEST: Get the ref pos app side. CheckForObserverEventTestsL(KTimeOut, *this); // << ProcessAssistanceData() TLbsAsistanceDataGroup dataMask = EAssistanceDataReferenceTime; RLbsAssistanceDataBuilderSet assistanceData; ArgUtils::PopulateLC(assistanceData); TInt reason = KErrNone; proxy->CallL(ENetMsgProcessAssistanceData, &dataMask, &assistanceData, &reason); CleanupStack::PopAndDestroy(); // assistanceData // << ProcessLocationRequest(SessionId, HybridMode, alpha2) TBool emergency = EFalse; MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation; TLbsNetPosRequestQuality quality = ArgUtils::Quality(); quality.SetMaxFixTime(ArgUtils::Alpha2()); TLbsNetPosRequestMethod method = ArgUtils::RequestHybridMethod(); proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method); // Now that the hybrid/alpha2 has been requested, record current time to verify alpha2 timer expires correctly. TTime startTime; startTime.HomeTime(); // >> RequestAssistanceData(0) TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); // << NotifyPositionUpdate() pWatch->IssueNotifyPositionUpdate(); // >> RequestAssistanceData(0) TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); // Determine the value to take off the alpha2 value. This is required because we had to wait for the assistance data response. TTimeIntervalMicroSeconds microseconds; TTime stopTime; stopTime.HomeTime(); microseconds = stopTime.MicroSecondsFrom(startTime); TInt64 timeElapsed = microseconds.Int64(); TInt delta = 2 * 1000 * 1000; // 2 secs. // >> RespondLocationRequest() TESTL(proxy->WaitForResponse(ArgUtils::Alpha2() - timeElapsed - delta) == ENetMsgTimeoutExpired); // Wait for and process the response. TESTL(proxy->WaitForResponse(2 * delta) == ENetMsgRespondLocationRequest); // DONT get because the measurement data bus has not been created... sessionId = NULL; TPositionGpsMeasurementInfo* measurementInfo = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &measurementInfo); TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); TESTL(reason == KErrNone); CleanupStack::PopAndDestroy(cleanupCnt);//sessionId, measurementInfo // Recv -> RequestAssistanceData - we get an extra msg as the result of the A-GPS manager re-issueing a location request when it's // max fix time timer expries. TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); const TInt t = 8 * 1000 * 1000; // 8 secs. quality.SetMaxFixTime(t); TPositionInfo* positionInfo = NULL; for (TInt i = 0; i < KN; i++) { // << ProcessLocationRequest(SessionId, HybridMode, t) proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method); // >> RequestAssistanceData(0) TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); // >> RespondLocationRequest() - first measurement, second position. TESTL(proxy->WaitForResponse(t + delta) == ENetMsgRespondLocationRequest); sessionId = NULL; // Expect measurement first time. if (i < (KN-1)) { measurementInfo = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &measurementInfo); // Check it is measurement TESTL(measurementInfo->PositionClassType() == EPositionGpsMeasurementInfoClass); // >> RequestAssistanceData - we get an extra msg as the result of the A-GPS manager re-issueing a location request when it's // max fix time timer expries. TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt += proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); TESTL(reason == KErrNone); } // Expect position second time. else { cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo); // check it is a position TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass|EPositionExtendedSatelliteInfoClass)); TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); TESTL(reason == KErrNone); // Client recv - the gps position determined by the gps module. CheckForObserverEventTestsL(KTimeOut, *this); TESTL(iState == EGpsLocReceived); // << ProcessLocationUpdate(SessionId, FinalNetworkPosition) // Return modules' position as FinalNetworkPosition proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, positionInfo); } CleanupStack::PopAndDestroy(cleanupCnt);// sessionId, measurementInfo/positionInfo } // << ProcessSessionComplete(SessionId, KErrNone) reason = KErrNone; proxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason); // << ENetMsgProcessStatusUpdate() MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask serviceMask = MLbsNetworkProtocolObserver::EServiceNone; proxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask); // Done. Now cleanup... CleanupStack::PopAndDestroy(pWatch); CleanupStack::PopAndDestroy(); // pos CleanupStack::PopAndDestroy(); // server CleanupStack::PopAndDestroy(proxy); return TestStepResult(); }
TVerdict CT_LbsMolrResetAssistance::doTestStepL() { INFO_PRINTF1(_L("CT_LbsMolrResetAssistance::doTestStepL()")); // Stop the test if the preable failed TESTL(TestStepResult() == EPass); iModuleWarmedUp = EFalse; iExpectExtraRequestForAssistanceData = EFalse; DoNetworkProtocolProxyStepL(); do { iState = EInitializing; // Do the /actual/ test step! RPositionServer server; TESTL(KErrNone == server.Connect()); CleanupClosePushL(server); RPositioner pos; TESTL(KErrNone == pos.Open(server)); CleanupClosePushL(pos); CPosServerWatcher *pWatch = CPosServerWatcher::NewLC(pos, *this); if(iModuleWarmedUp) { iWarmUpModule = EFalse; } if(!iWarmUpModule && iStepForSendingReset == EBeforeSession) { SendResetAssistanceDataL(); } // <<(App) NotifyPositionUpdate(). INFO_PRINTF1(_L("CT_LbsMolrResetAssistance::doTestStepL() <<(App) NotifyPositionUpdate()")); pWatch->IssueNotifyPositionUpdate(); DoNetworkProtocolProxyStepL(); // TEST: Get NotifyPositionUpdate app side - get the ref pos. INFO_PRINTF1(_L("CT_LbsMolrResetAssistance::doTestStepL() Waiting for ref pos")); CheckForObserverEventTestsL(KTimeOut, *this); if(!iGPSModeNotSupported) { // if it can still carry on since the module didn't reject the request INFO_PRINTF1(_L("CT_LbsMolrResetAssistance::doTestStepL() <<(App) NotifyPositionUpdate()")); pWatch->IssueNotifyPositionUpdate(); DoNetworkProtocolProxyStepL(); // Client recv - the gps position determined by the gps module. INFO_PRINTF1(_L("CT_LbsMolrResetAssistance::doTestStepL() Waiting for gps pos")); CheckForObserverEventTestsL(KTimeOut, *this); if(!iGPSModeNotSupported) { TESTL(iState == EGpsLocReceived); DoNetworkProtocolProxyStepL(); } } // Done. Now cleanup... CleanupStack::PopAndDestroy(pWatch); CleanupStack::PopAndDestroy(&pos); CleanupStack::PopAndDestroy(&server); iModuleWarmedUp = ETrue; } while(iWarmUpModule); 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 }
TVerdict CT_LbsATAEarlyComplete::doTestStepL() { INFO_PRINTF1(_L("<<CT_LbsATAEarlyComplete::doTestStepL()")); INFO_PRINTF1(_L("CT_LbsATAEarlyComplete::doTestStepL()")); // Stop the test if the preable failed TESTL(TestStepResult() == EPass); INFO_PRINTF1(_L(">>CT_LbsStep_SetupRoamSelfLocate::doTestStepL()")); CLbsAdmin* adminApi = CLbsAdmin::NewL(); CleanupStack::PushL(adminApi); // Switch on the self locate API when roaming. CLbsAdmin::TSelfLocateService serviceSetting = CLbsAdmin::ESelfLocateUnknown; TInt err = adminApi->Set(KLbsSettingRoamingSelfLocate, CLbsAdmin::ESelfLocateOn); User::LeaveIfError(err); err = adminApi->Get(KLbsSettingRoamingSelfLocate, serviceSetting); User::LeaveIfError(err); if(serviceSetting != CLbsAdmin::ESelfLocateOn) { INFO_PRINTF1(_L("Self locate API admin setting didn't work")); SetTestStepResult(EFail); } // Set gps mode when roaming. CLbsAdmin::TGpsMode gpsModeSetting = CLbsAdmin::EGpsModeUnknown; err = adminApi->Set(KLbsSettingRoamingGpsMode, CLbsAdmin::EGpsAlwaysTerminalAssisted); User::LeaveIfError(err); err = adminApi->Get(KLbsSettingRoamingGpsMode, gpsModeSetting); User::LeaveIfError(err); if (gpsModeSetting != CLbsAdmin::EGpsAlwaysTerminalAssisted) { INFO_PRINTF1(_L("Gps mode admin setting didn't work")); SetTestStepResult(EFail); } CLbsAdmin::TSpecialFeature ignoreAccuracy; TInt err1 = adminApi->Get(KLbsSpecialFeatureIgnoreAccuracy, ignoreAccuracy); if (err1 != KErrNone) { INFO_PRINTF1(_L("<< KLbsSpecialFeatureIgnoreAccuracy is absent in admin;")); } else { INFO_PRINTF2(_L("<< KLbsSpecialFeatureIgnoreAccuracy is in admin and it's set to %d;"),ignoreAccuracy); } //INFO_PRINTF1(_L("<< Setting KLbsSpecialFeatureIgnoreAccuracy to OFF")); //err = adminApi->Set(KLbsSpecialFeatureIgnoreAccuracy, CLbsAdmin::ESpecialFeatureOff;); CleanupStack::PopAndDestroy(adminApi); // Allow the setting to be propagated User::After(2*1000*1000); const TInt KTimeOut = 60*1000*1000; // Create Network Protocol Proxy CNetProtocolProxy* proxy = CNetProtocolProxy::NewL(); CleanupStack::PushL(proxy); // Recv --> GetCurrentCapabilitiesResponse. // Soak up the Lbs System Status (produced by A-GPS Manager startup).} TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgGetCurrentCapabilitiesResponse); CLbsNetworkProtocolBase::TLbsSystemStatus status; TInt cleanupCnt; cleanupCnt = proxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status); TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone); CleanupStack::PopAndDestroy(cleanupCnt); // Setup location session and position watcher. RPositionServer server; TESTL(KErrNone == server.Connect()); CleanupClosePushL(server); RPositioner pos; TESTL(KErrNone == pos.Open(server)); CleanupClosePushL(pos); // Set the max fix time for the client request to ensure the location server does not complete the request too soon during the test. TPositionUpdateOptions posOpts(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(240000000)); pos.SetUpdateOptions(posOpts); CPosServerWatcher *pWatch = CPosServerWatcher::NewLC(pos, *this); // Client Send - a self-locate request. pWatch->IssueNotifyPositionUpdate(); TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestSelfLocation); // Process the response. TLbsNetSessionId* sessionId = NULL; TLbsNetPosRequestOptionsAssistance* opts = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts); TBool qualitycheck = ArgUtils::CompareQuality( opts, ETrue, KMinHorizontalAcc, KMinVerticalAcc, KMOLRFixTime, 0, EAssistanceDataReferenceTime, (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted) ); TESTL(qualitycheck); iSessionId.SetSessionNum(sessionId->SessionNum()); iSessionId.SetSessionOwner(sessionId->SessionOwner()); CleanupStack::PopAndDestroy(cleanupCnt); sessionId = NULL; opts = NULL; // Send <-- ProcessStatusUpdate. MLbsNetworkProtocolObserver::TLbsNetProtocolService serviceMask = MLbsNetworkProtocolObserver::EServiceSelfLocation; proxy->CallL(ENetMsgProcessStatusUpdate, &serviceMask); // Send <-- ProcessAssistanceData. TLbsAsistanceDataGroup dataMask = EAssistanceDataReferenceTime; RLbsAssistanceDataBuilderSet data; TInt reason = KErrNone; ArgUtils::PopulateLC(data); proxy->CallL(ENetMsgProcessAssistanceData, &dataMask, &data, &reason); CleanupStack::PopAndDestroy(); // data // Send <-- ProcessLocationRequest. TBool emergency = EFalse; MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation; TLbsNetPosRequestQuality quality = ArgUtils::Quality(); TLbsNetPosRequestMethod method = ArgUtils::RequestTAPMethod(); quality.SetMaxFixTime(ArgUtils::Alpha2()); proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method); // Now that the hybrid/alpha2 has been requested, record current time to verify alpha2 timer expires correctly. TTime startTime; startTime.HomeTime(); // Recv --> RequestAssistanceData. TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); // Determine the value to take off the alpha2 value. This is required because we had to wait for the assistance data response. TTimeIntervalMicroSeconds microseconds; TTime stopTime; stopTime.HomeTime(); microseconds = stopTime.MicroSecondsFrom(startTime); TInt64 timeElapsed = microseconds.Int64(); // Recv --> RespondLocationRequest. // First ensure we don't recv response before Alpha2. TInt delta = 2 * 1000 * 1000; // 2 secs. TESTL(proxy->WaitForResponse(ArgUtils::Alpha2() - timeElapsed - delta) == ENetMsgTimeoutExpired); // Wait for and process the response. TESTL(proxy->WaitForResponse(2 * delta) == ENetMsgRespondLocationRequest); TPositionGpsMeasurementInfo* measurementInfo = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &measurementInfo); TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); TESTL(reason == KErrNone); TESTL(measurementInfo->PositionClassType() == EPositionGpsMeasurementInfoClass); CleanupStack::PopAndDestroy(cleanupCnt); sessionId = NULL; measurementInfo = NULL; // Recv -> RequestAssistanceData - we get an extra msg as the result of the A-GPS manager re-issueing a location request when it's // max fix time timer expries. TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); const TInt t = 8 * 1000 * 1000; // 8 secs. quality.SetMaxFixTime(t); // Send <-- ProcessLocationUpdate - return network calculated pos. TPositionInfo networkPosInfo = ArgUtils::MolrNetworkPositionInfo(); proxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &networkPosInfo); // Client Recv: Second update position - This should return with KPositionEarlyComplete CheckForObserverEventTestsL(KTimeOut, *this); // Wait to ensure no additional responses turn up. delta = 10 * 1000 * 1000; TNetProtocolResponseType rtype = proxy->WaitForResponse(delta); if (rtype == ENetMsgTimeoutExpired) { INFO_PRINTF1(_L("No additional messages turned up")); } else { INFO_PRINTF1(_L("Got unexpected messages")); } TESTL(rtype == ENetMsgCancelSelfLocation); // Send <-- ProcessSessionComplete. reason = KErrNone; proxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason); // Carryout unique test actions (the ALT sections - see sequence diagrams. TInt testCaseId; if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId)) { switch (testCaseId) { // Test case Stop_OutsideMoLr case 6: { User::After(2*1000*1000); iAGpsHandler->SendRequestModuleOption(ELbsHybridModuleOptions_DisableReqAssistData, ETrue); // Client Send: Notify Position Update pWatch->IssueNotifyPositionUpdate(); // now ensure that intgration moulde does NOT RequestAssistanceData // and thus LBS will NOT send RequestSelfLopcation to protocol module // and a MoLr will NOT be started // Client Send: Complete Request TESTL(pos.CompleteRequest(EPositionerNotifyPositionUpdate) == KErrNone); // Client Recv: Second update position - This should return with KPositionEarlyComplete CheckForObserverEventTestsL(KTimeOut, *this); TESTL(iState == EGotCompleteRequestPosition); } break; // Test case Stop_InsideMoLr case 5: { // Client Send: Notify Position Update User::After(2*1000*1000); pWatch->IssueNotifyPositionUpdate(); rtype = proxy->WaitForResponse(KTimeOut); TESTL(rtype == ENetMsgRequestSelfLocation); // Process the response. sessionId = NULL; opts = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts); qualitycheck = ArgUtils::CompareQuality( opts, EFalse, KMinHorizontalAcc, KMinVerticalAcc, KMOLRFixTime, 0, EAssistanceDataNone, (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted) ); TESTL(qualitycheck); iSessionId.SetSessionNum(sessionId->SessionNum()); iSessionId.SetSessionOwner(sessionId->SessionOwner()); CleanupStack::PopAndDestroy(cleanupCnt); sessionId = NULL; opts = NULL; // Send <-- ProcessLocationRequest. TBool emergency = EFalse; MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceSelfLocation; TLbsNetPosRequestQuality quality = ArgUtils::Quality(); TLbsNetPosRequestMethod method = ArgUtils::RequestTAPMethod(); quality.SetMaxFixTime(ArgUtils::Alpha2()); proxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method); // Now that the hybrid/alpha2 has been requested, record current time to verify alpha2 timer expires correctly. TTime startTime; startTime.HomeTime(); // Recv --> RequestAssistanceData. TESTL(proxy->WaitForResponse(KTimeOut) == ENetMsgRequestAssistanceData); cleanupCnt = proxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask); TESTL(dataMask == EAssistanceDataNone); CleanupStack::PopAndDestroy(cleanupCnt); //Client Send: CompleteRequest TESTL(pos.CompleteRequest(EPositionerNotifyPositionUpdate) == KErrNone); // Client Recv: Second update position - This should return with KPositionEarlyComplete CheckForObserverEventTestsL(KTimeOut, *this); TESTL(iState == EDone); // Wait for and process the response. Should be aRespondLocationRequest(KErrNone,FinalNetworkPosition) rtype = proxy->WaitForResponse(KTimeOut); TESTL(rtype == ENetMsgRespondLocationRequest); sessionId = NULL; TPositionInfo* positionInfo = NULL; cleanupCnt = proxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo); // Check the response. TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass)); TESTL(sessionId->SessionNum() == iSessionId.SessionNum()); TESTL(reason == KErrNone); CleanupStack::PopAndDestroy(cleanupCnt); // Send <-- ProcessSessionComplete. reason = KErrNone; proxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason); } break; default: { User::Leave(KErrArgument); } break; } } else { INFO_PRINTF1(_L("<FONT><B>Failed to read from ini file correctly</B></FONT>")); SetTestStepResult(EFail); } // Wait for 10 seconds to ensure no additional responses turn up. delta = 10 * 1000 * 1000; TNetProtocolResponseType mType = proxy->WaitForResponse(delta); TESTL(mType == ENetMsgTimeoutExpired); // Done. Now cleanup... CleanupStack::PopAndDestroy(pWatch); CleanupStack::PopAndDestroy(); // pos CleanupStack::PopAndDestroy(); // server CleanupStack::PopAndDestroy(proxy); return TestStepResult(); }
// --------------------------------------------------------- // CT_LbsClientPosTp178::StartL // // (other items were commented in a header). // --------------------------------------------------------- // void CT_LbsClientPosTp178::StartL() { _LIT(KServiceAccept, "SAAA"); SetupPsyL(iUidTestPsy3); RPositioner positioner; TPositionInfo info = TPositionInfo(); ConnectL(); User::LeaveIfError(positioner.Open(iPosServer,iUidTestPsy3)); CleanupClosePushL(positioner); TInt Err = positioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KServiceAccept); TPositionUpdateOptions updateOptionsLong, updateOptionsShort; TTimeIntervalMicroSeconds longInterval(7000000); updateOptionsLong.SetUpdateTimeOut(longInterval); Err = positioner.SetUpdateOptions(updateOptionsLong); TTimeIntervalMicroSeconds shortInterval(2000000); updateOptionsShort.SetUpdateTimeOut(shortInterval); TPositionUpdateOptions theUpdateOptions; Err = positioner.GetUpdateOptions(theUpdateOptions); if (theUpdateOptions.UpdateTimeOut() != updateOptionsLong.UpdateTimeOut() || updateOptionsLong.UpdateTimeOut() != longInterval) { _LIT(KUpdateOptions, "The update option was not set correctly"); LogErrorAndLeaveL(KUpdateOptions); } _LIT(KDelayMsg, "The successfull requests was completed within %d microsecs."); _LIT(KCancelMsg, "The canceled requests was completed within %d microsecs."); TRequestStatus status; for (TInt i = 0; i < 10; i++) // makes 10 test inorder to get some statistic { positioner.SetUpdateOptions(updateOptionsLong); TTime requestStartTime; requestStartTime.UniversalTime(); positioner.NotifyPositionUpdate(info, status); User::WaitForRequest(status); TTime requestStopTime; requestStopTime.UniversalTime(); TTimeIntervalMicroSeconds durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime); TInt duration = durationMicro.Int64(); TBuf<100> timeMsg; timeMsg.Format(KDelayMsg, duration); INFO_PRINTF1(timeMsg); //check error status if (status != KErrNone) { _LIT(KErrPositionRequest, "error code returned from NotifyPositionUpdate, error code = %d"); TBuf<100> buf; buf.Format(KErrPositionRequest, status.Int()); LogErrorAndLeaveL(buf); } TTimeIntervalMicroSeconds shortInterval(2000000); updateOptionsShort.SetUpdateTimeOut(shortInterval); positioner.SetUpdateOptions(updateOptionsShort); requestStartTime.UniversalTime(); positioner.NotifyPositionUpdate(info, status); User::WaitForRequest(status); requestStopTime.UniversalTime(); durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime); duration = durationMicro.Int64(); #ifdef __WINS__ TTimeIntervalMicroSeconds winsFail(100000); durationMicro = TTimeIntervalMicroSeconds(durationMicro.Int64()+winsFail.Int64()); #endif timeMsg.Format(KCancelMsg, duration); INFO_PRINTF1(timeMsg); if (status != KErrTimedOut) { _LIT(KErrPositionRequest, "Request did not returned KErrTimedOut, status code = %d."); TBuf<100> buf; buf.Format(KErrPositionRequest, status.Int()); LogErrorAndLeaveL(buf); } //Check that the request was not aborted before the Interval //Remove this condition if a lot of data is needed in test log. if (durationMicro < shortInterval) { _LIT(KErrInterval, " The request was aborted before the set timed out "); LogErrorAndLeaveL(KErrInterval); } } // end for loop CleanupStack::PopAndDestroy(1); //positioner Disconnect(); // Do timeout test TestTimeoutL(); // Do cancel test TestCancelL(); // ESLI-5QRA7U just check that it is not possible to set a timeout that is less than // the update interval TestOptionL(); }
// // 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); }
/** * Performes the test by connecting to MLFW and makes 50 Location request */ TInt DoTestL() { TBuf<40> traceFile = GenerateFileNameForTraceL(); RFs fileserver; RFile file; User::LeaveIfError(fileserver.Connect()); CleanupClosePushL(fileserver); User::LeaveIfError(file.Open(fileserver, traceFile, EFileWrite)); CleanupClosePushL(file); _LIT(KClientStarted, "Client Started"); TraceL(KClientStarted, file); const TInt32 KUidMultiPsy = 0x01010176; TUid uidMultiPsy; uidMultiPsy.iUid = KUidMultiPsy; SetupPsyL(uidMultiPsy); _LIT(KMultiPsySetup, "MultiPsy set up"); TraceL(KMultiPsySetup, file); TInt numberOfRuns = 50; RPositionServer posServer; CleanupClosePushL(posServer); RPositioner positioner; CleanupClosePushL(positioner); TPositionInfo positionInfo = TPositionInfo(); _LIT(KConnectErr, "ERROR: Error when connecing to EPos server, %d"); TInt err = posServer.Connect(); AssertTrueL(err == KErrNone, KConnectErr, err, file); _LIT(KOpenErr, "ERROR: Error when opening positioner, %d"); err = positioner.Open(posServer, uidMultiPsy); AssertTrueL(err == KErrNone, KOpenErr, err, file); _LIT(KService ,"Service"); err = positioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KService); _LIT(KRequestor, "ERROR: Not possible to set requestor"); AssertTrueL(err == KErrNone, KRequestor, err, file); TTime now, startTime; TTimeIntervalMicroSeconds requestTime; TRequestStatus status; TInt64 reqTime; TCoordinate corr(0,0,0); TLocality loca(corr,0); TPosition pos(loca, TTime(0)); TBool success = ETrue; _LIT(KStartingRequests, "Starting requests"); TraceL(KStartingRequests, file); for (TInt i = 0; i < numberOfRuns; i++) { startTime.UniversalTime(); positionInfo.SetPosition(pos); positioner.NotifyPositionUpdate(positionInfo, status); User::WaitForRequest(status); err = status.Int(); if (err != KErrNone) { success=EFalse; } now.UniversalTime(); requestTime = now.MicroSecondsFrom(startTime); _LIT(KError, "Request time, %d µs. Error code from Notify = %d"); TBuf<100> buf; reqTime = requestTime.Int64(); buf.Format(KError, reqTime, err); TraceL(buf, file); TPosition result; positionInfo.GetPosition(result); // Sanity check if (result.Latitude() == pos.Latitude() || result.Longitude() == pos.Longitude() || result.Altitude() == pos.Altitude()) { success = EFalse; _LIT(KErrorPositon, "ERROR:: The postion was not updated"); TraceL(KErrorPositon, file); } } CleanupStack::PopAndDestroy(&positioner); CleanupStack::PopAndDestroy(&posServer); if (success) { _LIT(KOk, "SUCCESS"); TraceL(KOk, file); } else { _LIT(KErr, "FAILED"); TraceL(KErr, file); } CleanupStack::PopAndDestroy(&file); CleanupStack::PopAndDestroy(&fileserver); return (success) ? 0 : 1; }