void CTTGPSLoggerPositionRequester::StartL()
{
Stop();
//RDebug::Print(_L("%d\n"), __LINE__);
#ifdef POSMETH
TPositionModuleInfo info;
if ( (iPositioningMethod>0) &&
((iPositionServer.GetModuleInfoByIndex(iPositioningMethod-1,info) == KErrNone) && (info.IsAvailable())) )
{
User::LeaveIfError(iPositioner.Open(iPositionServer, info.ModuleId()));
}
else
#endif
User::LeaveIfError(iPositioner.Open(iPositionServer));
//RDebug::Print(_L("%d\n"), __LINE__);
User::LeaveIfError(iPositioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KRequestor));
//RDebug::Print(_L("%d\n"), __LINE__);
const TTimeIntervalMicroSeconds KUpdateInterval(1000000);
const TTimeIntervalMicroSeconds KTimeOut(2000000);
const TTimeIntervalMicroSeconds KMaxUpdateAge(0);
TPositionUpdateOptions options;
options.SetUpdateInterval(KUpdateInterval);
options.SetUpdateTimeOut(KTimeOut);
options.SetMaxUpdateAge(KMaxUpdateAge);
options.SetAcceptPartialUpdates(ETrue);
//RDebug::Print(_L("%d\n"), __LINE__);
User::LeaveIfError(iPositioner.SetUpdateOptions(options));
//RDebug::Print(_L("%d\n"), __LINE__);
iPositioner.NotifyPositionUpdate(*iPositionInfo, iStatus);
//RDebug::Print(_L("%d\n"), __LINE__);
SetActive();
}
EXPORT_C void T_LbsUtils::GetConfigured_ModuleUpdateOptionsL(const TDesC& aConfigFileName, const TDesC& aConfigSection, TPositionUpdateOptions& aUpdateOpts)
/** Fills a module updata options class/structure with values read from a configuration ini file.
@param aConfigFileName The name of the ini file to read. If the file name is empty (0 length) then
default values will be used.
@param aConfigSection The section within the ini file to read data from.
@param aUpdateOpts The modified update options structure.
*/
{
// Use default values if file name not given.
if (aConfigFileName.Length() == 0)
{
aUpdateOpts.SetUpdateInterval(0);
aUpdateOpts.SetUpdateTimeOut(0);
aUpdateOpts.SetMaxUpdateAge(0);
aUpdateOpts.SetAcceptPartialUpdates(EFalse);
}
else
{
CUpdateOptsConfigReader* reader;
reader = CUpdateOptsConfigReader::NewL(aConfigFileName, aConfigSection, aUpdateOpts);
CleanupStack::PushL(reader);
reader->ProcessL();
CleanupStack::PopAndDestroy(reader);
}
}
//////////////////////////////////////////////////////////////
// Sets the interval for getting the regular notification //
// the time interval set is in milli seconds //
//////////////////////////////////////////////////////////////
int CQMLBackendAO::setUpdateInterval(int aMilliSec)
{
#if !defined QT_NO_DEBUG
qDebug() << "CQMLBackendAO::setUpdateInterval\n" ;
#endif
int minimumUpdateInterval = 0;
TInt64 mUpdateInterval = 0 ;
if (mRequester)
minimumUpdateInterval = mRequester->minimumUpdateInterval();
else
minimumUpdateInterval = mRequesterSatellite->minimumUpdateInterval();
if (minimumUpdateInterval < 0)
minimumUpdateInterval = 100;
// if the current requesttype is regular updates
// then set the updateinterval otherwise ignore
//if(mRequestType != REQ_REG_UPDATE)
// return;
TPositionUpdateOptions aPosOption;
TInt error = mPositioner.GetUpdateOptions(aPosOption);
// TTimeIntervalMicroSeconds is converted seconds
TInt currentUpdateInterval = aPosOption.UpdateInterval().Int64() / 1000;
// If msec is not 0 and is less than the value returned by minimumUpdateInterval(),
// the interval will be set to the minimum interval.
// if (aMilliSec != 0 && aMilliSec <= minimumUpdateInterval) {
// workaround, not accepting zero as value, see QTMOBILITY-995
if (aMilliSec <= minimumUpdateInterval) {
mUpdateInterval = minimumUpdateInterval;
} else {
mUpdateInterval = aMilliSec;
}
// if the same value is being set then just ignore it.
if (currentUpdateInterval == mUpdateInterval) {
return mUpdateInterval;
}
// will set Either zero, minimum or +ve value
// seconds converted to TTimeIntervalMicroSeconds
aPosOption.SetUpdateInterval(TTimeIntervalMicroSeconds(mUpdateInterval * 1000));
// set the timeout to the smaller of 150% of interval or update interval + 10 seconds
TInt64 mUpdateTimeout = (mUpdateInterval * 3) / 2;
if (mUpdateTimeout > mUpdateInterval + 10000)
mUpdateTimeout = mUpdateInterval + 10000;
if (aMilliSec > 0)
aPosOption.SetUpdateTimeOut(TTimeIntervalMicroSeconds(mUpdateTimeout * 1000));
error = mPositioner.SetUpdateOptions(aPosOption);
return mUpdateInterval;
}
void CPosition::ConstructL()
{
User::LeaveIfError(iServer.Connect());
User::LeaveIfError(iPositioner.Open(iServer));
_LIT(KRequestor, "OpenMAR" );
User::LeaveIfError(iPositioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KRequestor));
const TInt KSecond = 1000000;
TPositionUpdateOptions updateOptions;
updateOptions.SetUpdateInterval(TTimeIntervalMicroSeconds(10 * KSecond));
updateOptions.SetUpdateTimeOut(TTimeIntervalMicroSeconds(30 * KSecond));
updateOptions.SetMaxUpdateAge(TTimeIntervalMicroSeconds(1 * KSecond));
updateOptions.SetAcceptPartialUpdates(EFalse);
User::LeaveIfError(iPositioner.SetUpdateOptions(updateOptions));
}
//requestUpdate : request for position update once
void CQMLBackendAO::requestUpdate(int aTimeout)
{
#if !defined QT_NO_DEBUG
qDebug() << "CQMLBackendAO::requestUpdate\n" ;
#endif
TPositionUpdateOptions aPosOption;
mPositioner.GetUpdateOptions(aPosOption);
aPosOption.SetUpdateInterval(TTimeIntervalMicroSeconds(0));
aPosOption.SetUpdateTimeOut(TTimeIntervalMicroSeconds(aTimeout * 1000));
mPositioner.SetUpdateOptions(aPosOption);
startUpdates();
}
void CGpsPositionRequest::ConstructL(const TDesC& aAppName)
{
iAppName = aAppName.AllocL();
// connect to location server
User::LeaveIfError(iLocationServer.Connect());
// open positioner
User::LeaveIfError(iPositioner.Open(iLocationServer));
// set our application as location requestor
User::LeaveIfError(iPositioner.SetRequestor(
CRequestor::ERequestorService, CRequestor::EFormatApplication, *iAppName));
// set maximum allowed time for a location request
TTimeIntervalMicroSeconds timeOut(30000000); // 30 sec
// TTimeIntervalMicroSeconds timeOut(3000000000); // 50 minutes sec
TPositionUpdateOptions updateOptions;
updateOptions.SetUpdateTimeOut(timeOut);
User::LeaveIfError(iPositioner.SetUpdateOptions(updateOptions));
}
void CCxxPositioner::ConstructL()
{
LEAVE_IF_ERROR_OR_SET_SESSION_OPEN(iPositionServer, iPositionServer.Connect());
LEAVE_IF_ERROR_OR_SET_SESSION_OPEN(iPositioner, iPositioner.Open(iPositionServer, iModuleId));
_LIT(KRequestor, "pytwink");
User::LeaveIfError(iPositioner.SetRequestor(CRequestor::ERequestorService,
CRequestor::EFormatApplication,
KRequestor));
TPositionUpdateOptions updateOptions;
updateOptions.SetAcceptPartialUpdates(EFalse);
updateOptions.SetUpdateInterval(TTimeIntervalMicroSeconds(0)); // not periodic
updateOptions.SetUpdateTimeOut(TTimeIntervalMicroSeconds(iUpdateTimeOut));
updateOptions.SetMaxUpdateAge(TTimeIntervalMicroSeconds(iMaxUpdateAge));
User::LeaveIfError(iPositioner.SetUpdateOptions(updateOptions));
}
void CAzqInternalGPSReader::StartL()
{
Cancel();
_LIT(KOurAppName,"AzenqosTester");
User::LeaveIfError(iPositioner.SetRequestor(
CRequestor::ERequestorService, CRequestor::EFormatApplication, KOurAppName));
TPositionUpdateOptions options;
// Frequency of updates in microseconds
const TTimeIntervalMicroSeconds KUpdateInterval(3*KMillion);
// How long the application is willing to wait before timing out the request
const TTimeIntervalMicroSeconds KTimeOut(60*KMillion);
// The maximum acceptable age of the information in an update
const TTimeIntervalMicroSeconds KMaxUpdateAge(2*KMillion);
options.SetUpdateInterval(KUpdateInterval);
options.SetUpdateTimeOut(KTimeOut);
options.SetMaxUpdateAge(KMaxUpdateAge);
options.SetAcceptPartialUpdates(EFalse);
User::LeaveIfError(iPositioner.SetUpdateOptions(options));
/* Now when the application requests location information
it will be provided with these options */
iState = EReading;
iPositioner.NotifyPositionUpdate(iPositionInfo, iStatus);
SetActive();
}
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();
}
// ---------------------------------------------------------
// CT_LbsClientPosTp178::TestTimeout
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp178::TestTimeoutL()
{
_LIT(KSTART, "TestTimeout()");
_LIT(KEND, "TestTimeout() passed");
_LIT(KTIME, "Request took %d us");
// Setup verification stuff
INFO_PRINTF1(KSTART);
//TPrivDlgDiagnostics tmpdiag;
TTime requestStartTime;
TTime requestStopTime;
TTimeIntervalMicroSeconds durationMicro;
TBuf<100> buf;
_LIT(KService, "SAAA");
TPositionUpdateOptions updateOptions;
TTimeIntervalMicroSeconds longInterval(7000000);
ConnectL();
SetupPsyL(iUidTestPsy3);
OpenPositionerByName(iUidTestPsy3);
updateOptions.SetUpdateTimeOut(longInterval);
// Access protected member (iPositioner) here
iPositioner.SetUpdateOptions(updateOptions);
_LIT(KONE, "Perform first request, should NOT time out");
INFO_PRINTF1(KONE);
requestStartTime.UniversalTime();
//Make one request to verify psy
PerformRequestL(KService, CRequestor::ERequestorService, CRequestor::EFormatApplication);
CheckRequestResultL(KErrNone);
requestStopTime.UniversalTime();
durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime);
TInt duration = durationMicro.Int64();
buf.Format(KTIME, duration);
INFO_PRINTF1(buf);
ClosePositioner();
OpenPositionerByName(iUidTestPsy3);
// ECancelButton means that the Automatised class should wait for a cancel call
// before returning result
updateOptions.SetUpdateTimeOut(longInterval);
// Access protected (iPositioner) member here
iPositioner.SetUpdateOptions(updateOptions);
_LIT(KTWO, "Perform second request, should not time out");
INFO_PRINTF1(KTWO);
//Make one request to verify psy
TPositionInfo info = TPositionInfo();
requestStartTime.UniversalTime();
TInt err = PerformSyncRequest(KService, &info);
requestStopTime.UniversalTime();
if (err != KErrNone)
{
_LIT(KError, "Wrong result from iStatus, should be KErrNone, was %d");
TBuf<100> buf;
buf.Format(KError, err);
LogErrorAndLeaveL(buf);
}
durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime);
duration = durationMicro.Int64();
buf.Format(KTIME, duration);
INFO_PRINTF1(buf);
ClosePositioner();
Disconnect();
INFO_PRINTF1(KEND);
}
void CGpsDataHandler::RunL() {
#ifndef __SERIES60_3X__
TPtr8 pBuffer = iBuffer->Des();
THostName aHostName;
TInquirySockAddr aInquiry;
TInt aServiceClass;
switch(iEngineStatus) {
case EGpsResolving:
if(iStatus == KErrNone) {
// Next device found
aHostName = iNameEntry().iName;
aInquiry = TInquirySockAddr::Cast(iNameEntry().iAddr);
aServiceClass = aInquiry.MajorServiceClass();
iBTAddr.SetBTAddr(aInquiry.BTAddr());
iBTAddr.SetPort(1);
if(aServiceClass & 0x08 || aHostName.Find(_L("GPS")) != KErrNotFound || aHostName.Find(_L("gps")) != KErrNotFound) {
// Found Positioning device
if(iSocket.Open(iSocketServ, KBTAddrFamily, KSockStream, KRFCOMM) == KErrNone) {
iEngineStatus = EGpsConnecting;
//iResolver.Close();
iSocket.Connect(iBTAddr, iStatus);
SetActive();
}
else {
iSocketServ.Close();
iEngineStatus = EGpsDisconnected;
iObserver->GpsError(EGpsConnectionFailed);
}
}
else {
// Get next
iResolver.Next(iNameEntry, iStatus);
SetActive();
}
// TODO - Is correct device?
}
else if(iStatus == KErrHostResNoMoreResults) {
// No (more) devices found
iSocketServ.Close();
iEngineStatus = EGpsDisconnected;
iGpsDeviceResolved = false;
iObserver->GpsError(EGpsDeviceUnavailable);
}
else {
iSocketServ.Close();
iEngineStatus = EGpsDisconnected;
iObserver->GpsError(EGpsDeviceUnavailable);
}
break;
case EGpsConnecting:
if(iStatus == KErrNone) {
iEngineStatus = EGpsReading;
iGpsDeviceResolved = true;
iResolver.Close();
pBuffer.Zero();
iSocket.Recv(iChar, 0, iStatus);
SetActive();
}
else {
if(iGpsDeviceResolved) {
iSocket.Close();
iSocketServ.Close();
iEngineStatus = EGpsDisconnected;
iObserver->GpsError(EGpsConnectionFailed);
}
else {
// Get next
iEngineStatus = EGpsResolving;
iResolver.Next(iNameEntry, iStatus);
SetActive();
}
}
break;
case EGpsReading:
if(iStatus == KErrNone) {
iEngineStatus = EGpsConnected;
if(pBuffer.Length() + iChar.Length() > pBuffer.MaxLength()) {
iBuffer = iBuffer->ReAlloc(pBuffer.MaxLength()+iChar.Length());
pBuffer.Set(iBuffer->Des());
}
pBuffer.Append(iChar);
ProcessData();
}
else {
iSocket.Close();
iSocketServ.Close();
iEngineStatus = EGpsDisconnected;
iObserver->GpsError(EGpsConnectionFailed);
}
break;
case EGpsDisconnecting:
iResolver.Close();
iSocket.Close();
iSocketServ.Close();
iEngineStatus = EGpsDisconnected;
break;
default:;
}
#else
switch(iEngineStatus) {
case EGpsReading:
iEngineStatus = EGpsConnected;
if(iStatus == KErrNone) {
TPosition aPosition;
iPositionInfo.GetPosition(aPosition);
iObserver->GpsData(aPosition.Latitude(), aPosition.Longitude(), aPosition.HorizontalAccuracy());
if( !iGpsWarmedUp ) {
iGpsWarmedUp = true;
TPositionUpdateOptions aOptions;
aOptions.SetUpdateTimeOut(30000000);
aOptions.SetAcceptPartialUpdates(true);
iPositioner.SetUpdateOptions(aOptions);
}
}
else {
iObserver->GpsError(EGpsDeviceUnavailable);
}
break;
case EGpsDisconnecting:
iPositioner.Close();
iPositionServ.Close();
iEngineStatus = EGpsDisconnected;
break;
default:;
}
#endif
}
/**
* @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.
*/
TVerdict CT_LbsClientStep_PartialUpdate::doTestStepL()
{
// Generic test step used to test the LBS SetUpdateOptions API.
INFO_PRINTF1(_L(">>CT_LbsClientStep_PartialUpdate::doTestStepL()"));
if (TestStepResult()==EPass)
{
TInt err = KErrNone;
iPosUpdateStatus = EPositionUpdateStart;
//Configure partial Updates
TPositionUpdateOptions optsA;
optsA.SetAcceptPartialUpdates(ETrue);
if(!optsA.AcceptPartialUpdates())
{
INFO_PRINTF1(_L("Partial Updates not set."));
SetTestStepResult(EFail);
}
err = iDoPosUpdatePtr->SetOptions(optsA);
User::LeaveIfError(err);
CLbsAdmin* lbsAdminApi = CLbsAdmin::NewL();
CleanupStack::PushL(lbsAdminApi);
// Carryout unique test actions.
if (GetIntFromConfig(ConfigSection(), KTestCaseId, iTestCaseId))
{
switch (iTestCaseId)
{
// Test case LBS-Partial-Update-Options-0001
case 1:
{
CLbsAdmin::TGpsMode gpsMode = CLbsAdmin::EGpsAutonomous;
lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);
//Configure Partial Update to EFalse
TPositionUpdateOptions updOpts;
updOpts.SetUpdateTimeOut(10*1000000);
updOpts.SetAcceptPartialUpdates(EFalse);
if(EFalse != updOpts.AcceptPartialUpdates())
{
INFO_PRINTF1(_L("Partial Updates not set."));
SetTestStepResult(EFail);
}
err = iDoPosUpdatePtr->SetOptions(updOpts);
User::LeaveIfError(err);
break;
}
// Test case LBS-Partial-Update-Options-0002
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
{
CLbsAdmin::TGpsMode gpsMode = CLbsAdmin::EGpsAutonomous;
lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);
break;
}
case 21:
case 22:
case 24:
case 25:
case 26:
{
CLbsAdmin::TGpsMode gpsMode = CLbsAdmin::EGpsPreferTerminalBased;
lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);
break;
}
case 23:
{
CLbsAdmin::TGpsMode gpsMode = CLbsAdmin::EGpsPreferTerminalBased;
lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);
//Configure Partial Update to EFalse
TPositionUpdateOptions updOpts;
updOpts.SetAcceptPartialUpdates(EFalse);
if(EFalse != updOpts.AcceptPartialUpdates())
{
INFO_PRINTF1(_L("Partial Updates not set."));
SetTestStepResult(EFail);
}
err = iDoPosUpdatePtr->SetOptions(updOpts);
User::LeaveIfError(err);
break;
}
case 27:
case 28:
{
//Tracking
CLbsAdmin::TGpsMode gpsMode;
if(iTestCaseId == 27)
{
gpsMode = CLbsAdmin::EGpsAutonomous;
}
else
{
gpsMode = CLbsAdmin::EGpsPreferTerminalBased;
}
lbsAdminApi->Set(KLbsSettingHomeGpsMode,gpsMode);
TPositionUpdateOptions updOpts;
updOpts.SetUpdateInterval(10*1000000); //Set Update Interval to 10 secs
updOpts.SetAcceptPartialUpdates(ETrue);
err = iDoPosUpdatePtr->SetOptions(updOpts);
User::LeaveIfError(err);
break;
}
default:
User::Panic(KLbsClientStep_PartialUpdate, KErrUnknown);
}
}
User::LeaveIfError(OpenNetSim());
// Kick off the test abort and keep alive timers.
TTimeIntervalMicroSeconds32 keepAliveInterval(KLbsKeepAlivePeriod);
iKeepAliveTimer->SetTimer(keepAliveInterval);
// Kick off test.
CActiveScheduler::Start();
// Verify location data.
VerifyPosInfos();
//Reset Test module timeout
TModuleDataIn modDataIn;
modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;
modDataIn.iTimeOut = 0;
T_LbsUtils utils;
utils.NotifyModuleOfConfigChangeL(modDataIn);
// Clean up.
CloseNetSim();
CleanupStack::PopAndDestroy(lbsAdminApi);
}
INFO_PRINTF1(_L("<<CT_LbsClientStep_PartialUpdate::doTestStepL()"));
return TestStepResult();
}
