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);
}
}
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();
}
// ---------------------------------------------------------
// CPosTp4707::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp4707::StartL()
{
ConnectL();
SetupProxyPSYsL();
TInt err = OpenPositioner();
_LIT(KOpenErr, "Error when opening positioner, %d");
AssertTrueL(err == KErrNone, KOpenErr, err);
_LIT(KServiceName, "TP4707");
iPositioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KServiceName);
// Issue a pre position request
TInt request = 100;
TPositionInfo posInfo;
RequestL(posInfo, request, KEspectedErrorCodePSY1);
//
// Request 1
//
// Check that partial update is not supported
TPositionUpdateOptions updateOptions;
updateOptions.SetAcceptPartialUpdates(ETrue);
iPositioner.SetUpdateOptions(updateOptions);
request = 4707;
RequestL(posInfo, request, KEspectedErrorCodePSY2);
VerifyPositionFromL(posInfo, iUidTestPsyPartialUpdate);
VerifyRequestTimeLessThanL(5001000);
VerifyPositionL(posInfo, 30, 40, 50);
}
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));
}
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 CGpsDataHandler::ResolveAndConnectL() {
TInt aResult;
#ifndef __SERIES60_3X__
if((aResult = iSocketServ.Connect()) == KErrNone) {
if(iGpsDeviceResolved) {
if((aResult = iSocket.Open(iSocketServ, KBTAddrFamily, KSockStream, KRFCOMM)) == KErrNone) {
iEngineStatus = EGpsConnecting;
iSocket.Connect(iBTAddr, iStatus);
SetActive();
}
}
else {
_LIT(KLinkMan, "BTLinkManager");
//_LIT(KLinkMan, "RFCOMM");
TProtocolName aProtocolName(KLinkMan);
if((aResult = iSocketServ.FindProtocol(aProtocolName, iProtocolDesc)) == KErrNone) {
if((aResult = iResolver.Open(iSocketServ, iProtocolDesc.iAddrFamily, iProtocolDesc.iProtocol)) == KErrNone) {
TInquirySockAddr aInquiry;
aInquiry.SetIAC(KGIAC);
//aInquiry.SetMajorServiceClass(EMajorServicePositioning);
aInquiry.SetAction(KHostResName | KHostResInquiry | KHostResIgnoreCache);
iResolver.GetByAddress(aInquiry, iNameEntry, iStatus);
iEngineStatus = EGpsResolving;
SetActive();
}
}
}
}
if(aResult != KErrNone) {
iEngineStatus = EGpsDisconnected;
iSocketServ.Close();
iObserver->GpsError(EGpsConnectionFailed);
}
#else
TBool aDeviceFound = false;
if((aResult = iPositionServ.Connect()) == KErrNone) {
iEngineStatus = EGpsConnecting;
TUint aNumOfModules;
if((aResult = iPositionServ.GetNumModules(aNumOfModules)) == KErrNone) {
TPositionModuleInfo aModuleInfo;
TUid aModuleId;
for(TUint i = 0; i < aNumOfModules && aResult == KErrNone && !aDeviceFound; i++) {
if((aResult = iPositionServ.GetModuleInfoByIndex(i, aModuleInfo)) == KErrNone) {
aModuleId = aModuleInfo.ModuleId();
if(aModuleInfo.IsAvailable() && aModuleInfo.TechnologyType() != TPositionModuleInfo::ETechnologyNetwork) {
aDeviceFound = true;
}
}
}
if(aResult == KErrNone && aDeviceFound) {
if((aResult = iPositioner.Open(iPositionServ, aModuleId)) == KErrNone) {
iEngineStatus = EGpsConnected;
if((aResult = iPositioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, _L("Buddycloud"))) == KErrNone) {
iEngineStatus = EGpsReading;
TPositionUpdateOptions aOptions;
aOptions.SetAcceptPartialUpdates(true);
iPositioner.SetUpdateOptions(aOptions);
iPositioner.NotifyPositionUpdate(iPositionInfo, iStatus);
SetActive();
}
if(aResult != KErrNone) {
iPositioner.Close();
}
}
}
}
}
if(aResult != KErrNone || !aDeviceFound) {
iEngineStatus = EGpsDisconnected;
iPositionServ.Close();
iObserver->GpsError(EGpsConnectionFailed);
}
#endif
}
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();
}
