// ---------------------------------------------------------
// 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);
}
// ---------------------------------------------------------
// CPosTp4702::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp4702::StartL()
{
ConnectL();
SetupProxyPSYsL();
TInt err = OpenPositioner();
_LIT(KOpenErr, "Error when opening positioner, %d");
AssertTrueL(err == KErrNone, KOpenErr, err);
_LIT(KServiceName, "TP4702");
iPositioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KServiceName);
//
// Request 1
//
TInt request = 4702;
TPositionInfo posInfo;
RequestL(posInfo, request, KEspectedErrorCodePSY1);
VerifyPositionFromL(posInfo, iUidTestProxyPsy1);
VerifyRequestTimeLessThanL(7500000);
/*Default proxy fallbacks to testproxypsy2 because of time-shift,fix will
be given by TestProxyPsy1 first.*/
VerifyPsyLoadedL(iUidTestProxyPsy1);
VerifyPsyLoadedL(iUidTestProxyPsy2);
VerifyPositionL(posInfo, 5, 15, 25);
}
// ---------------------------------------------------------
// CPosTp4723::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp4723::StartL()
{
ConnectL();
SetupProxyPSYsL();
TPositionModuleId modId = iUidSatInfoPsy;
CRepository* repos = CRepository::NewL( KCRUidDefaultProxyConfiguration );
TBuf<40> idBuf;
idBuf.AppendNumFixedWidth( modId.iUid, EHex, 8);
TInt error = repos->Set(KDefaultProxyLastWorkingGpsPsy, idBuf);
delete repos;
User::LeaveIfError(error);
TInt err = OpenPositioner();
_LIT(KOpenErr, "Error when opening positioner, %d");
AssertTrueL(err == KErrNone, KOpenErr, err);
_LIT(KServiceName, "TP4723");
iPositioner.SetRequestor(CRequestor::ERequestorService,
CRequestor::EFormatApplication, KServiceName);
TPositionSatelliteInfo posInfo;
// Request value should be 4722, even for TP4723...
TInt request = 4722;
// Default PSY won't pre-load Multi PSY since it is Internal
VerifyPsyUnloadedL(iUidMultiPsy);
// Default PSY should pre-load SetInfo PSY since it is External and supports GPS
VerifyPsyLoadedL(iUidSatInfoPsy);
//
// Request 1
//
RequestL(posInfo, request, KEspectedErrorCodePSY1);
VerifyPositionFromL(posInfo, iUidSatInfoPsy);
VerifyRequestTimeLessThanL(1200000);
VerifyPsyLoadedL(iUidSatInfoPsy);
VerifyPositionL(posInfo, 40, 50, 60);
}
// ---------------------------------------------------------
// CT_LbsClientPosTp1::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp1::StartL()
{
ConnectL();
CPosModules* db = CPosModules::OpenL();
CleanupStack::PushL(db);
SetupPsyL(iUidMultiPsy);
_LIT(KSetupPSY, "TP1: Has Setup Multi PSY");
INFO_PRINTF1(KSetupPSY);
//setting priority
TPositionModuleInfo moduleInfoHp;//Hp - high prio;
TPositionModuleInfo moduleInfoLp;//Lp - low prio;
CPosModuleIdList* prioList = db->ModuleIdListLC();
db->GetModuleInfoL(prioList->At(0), moduleInfoHp);
CPosModuleUpdate* moduleUpdate = CPosModuleUpdate::NewLC();
moduleUpdate->SetUpdateAvailability(ETrue);
if (iUidMultiPsy.iUid == moduleInfoHp.ModuleId().iUid)
{
// Case when Multi PSY has highest prio:
// Ensuring it is enabled
_LIT(KMultiHighest, "TP1: Case when Multi PSY has highest prio");
INFO_PRINTF1(KMultiHighest);
db->UpdateModuleL((*prioList)[0], *moduleUpdate);
}
else
{
// Case when Multi PSY has not highest prio:
//
_LIT(KMultiNotHighest, "TP1: Case when Multi PSY has NOT highest prio");
INFO_PRINTF1(KMultiNotHighest);
db->GetModuleInfoL(iUidMultiPsy, moduleInfoLp);
// Ensuring it is enabled
db->UpdateModuleL(iUidMultiPsy, *moduleUpdate);
TUint hp = db->PriorityL(moduleInfoHp.ModuleId());
TUint lp = db->PriorityL(moduleInfoLp.ModuleId());
// Changing prio of highest prio PSY and Multi PSY.
// Setting Multi PSY to highest prio
db->SetModulePriorityL(iUidMultiPsy, hp);
db->SetModulePriorityL((*prioList)[0], lp);
}
_LIT(KTestPSY1On, "TP1: Enabling Test PSY 1");
INFO_PRINTF1(KTestPSY1On);
db -> UpdateModuleL(iUidTestPsy1, *moduleUpdate);
_LIT(KTestPSY2On, "TP1: Enabling Test PSY 2");
INFO_PRINTF1(KTestPSY2On);
db -> UpdateModuleL(iUidTestPsy2, *moduleUpdate);
CleanupStack::PopAndDestroy(moduleUpdate);
CleanupStack::PopAndDestroy(2, db); // db, prioList
User::LeaveIfError(OpenPositioner());
// Request data from default psy should be Multi psy
_LIT(KService, "service");
TPositionInfo posInfo = TPositionInfo();
TInt err = PerformSyncRequest(KService, &posInfo);
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrNone");
LogErrorAndLeaveL(KErrorRequest, err);
}
if (iUidMultiPsy.iUid != posInfo.ModuleId().iUid)
{
_LIT(KIncorrectPsyError, "TP1. Position from wrong PSY received");
LogErrorAndLeaveL(KIncorrectPsyError);
}
HPositionGenericInfo* genericInfo = HPositionGenericInfo::NewLC();
err = PerformSyncRequest(KService, &(*genericInfo));
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrNone");
LogErrorAndLeaveL(KErrorRequest);
}
if (iUidMultiPsy.iUid != (genericInfo -> ModuleId()).iUid)
{
_LIT(KIncorrectPsyError,
"TP1. Position from wrong PSY received");
LogErrorAndLeaveL(KIncorrectPsyError);
}
TPositionCourseInfo courseInfo = TPositionCourseInfo();
err = PerformSyncRequest(KService, &courseInfo);
if (err != KErrNone)
{
_LIT(KErrorRequest, "Course info supported by default, but request failed");
LogErrorAndLeaveL(KErrorRequest);
}
TPositionSatelliteInfo satelliteInfo = TPositionSatelliteInfo();
err = PerformSyncRequest(KService, &satelliteInfo);
if (err != KErrNone)
{
_LIT(KErrorRequest, "Satellite info supported by default, but request failed");
LogErrorAndLeaveL(KErrorRequest);
}
//Changing the priority and verifiy that it still possilbe
//to request updated from a psy if basic position information
//is used and that it is not possilbe to request sat or cource
//any more.
SetupPsyL(iUidTestPsy2);
User::After(3000000);
// Request data from default psy should be test psy 2 now
err = PerformSyncRequest(KService, &posInfo);
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrNone");
LogErrorAndLeaveL(KErrorRequest);
}
if (iUidTestPsy2.iUid != posInfo.ModuleId().iUid)
{
_LIT(KIncorrectPsyError,
"TP1. Position from wrong PSY received");
LogErrorAndLeaveL(KIncorrectPsyError);
}
err = PerformSyncRequest(KService, &(*genericInfo));
if (err != KErrNone)
{
_LIT(KErrorRequest, "The request was not completed with KErrNone");
LogErrorAndLeaveL(KErrorRequest);
}
if (iUidTestPsy2.iUid != (genericInfo -> ModuleId()).iUid)
{
_LIT(KIncorrectPsyError,
"TP1. Position from wrong PSY received");
LogErrorAndLeaveL(KIncorrectPsyError);
}
err = PerformSyncRequest(KService, &courseInfo);
if (err != KErrArgument)
{
_LIT(KErrorRequest, "Course info not supported by default, KErrArgument not returned");
LogErrorAndLeaveL(KErrorRequest);
}
err = PerformSyncRequest(KService, &satelliteInfo);
if (err != KErrArgument)
{
_LIT(KErrorRequest, "Satellite info not supported by default, KErrArgument not returned");
LogErrorAndLeaveL(KErrorRequest);
}
//check that it is possilbe to change the different
//type of class info during periodic request and
//that the periodic update will fail if the class
//type is incorrect.
TTimeIntervalMicroSeconds interval = TTimeIntervalMicroSeconds(1000000);
TPositionUpdateOptions posOption;
posOption.SetUpdateInterval(interval);
_LIT(KUpdateErr, "Error when setting update interval, %d");
err = iPositioner.SetUpdateOptions(posOption);
AssertTrueL(err == KErrNone, KUpdateErr, err);
_LIT(KErrPeriodic, "The periodic request did not return KErrNone, %d");
err = PerformSyncRequest(KService, &posInfo);
AssertTrueL(err == KErrNone , KErrPeriodic, err);
_LIT(KErrPeriodicArr, "The periodic request did not return KErrArgument, %d");
err = PerformSyncRequest(KService, &satelliteInfo);
AssertTrueL(err == KErrArgument , KErrPeriodicArr, err);
SetupPsyL(iUidMultiPsy);
User::After(3000000);
err = PerformSyncRequest(KService, &satelliteInfo);
AssertTrueL(err == KErrNone , KErrPeriodic, err);
CleanupStack::PopAndDestroy(genericInfo);
ClosePositioner();
Disconnect();
}
// ---------------------------------------------------------
// CT_LbsClientPosTp261::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp261::StartL()
{
_LIT(KService1, "Service1");
_LIT(KService2, "Service2");
_LIT(KService3, "Service3");
_LIT(KContact1, "Contact1");
_LIT(KContact2, "Contact2");
_LIT(KContact3, "Contact3");
CRequestor* serviceId1 =
CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication,
KService1);
CRequestor* serviceId2 =
CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication,
KService2);
CRequestor* serviceId3 =
CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication,
KService3);
CRequestor* contactId1 =
CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatTelephone,
KContact1);
CRequestor* contactId2 =
CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatUrl,
KContact2);
CRequestor* contactId3 =
CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatMail,
KContact3);
RRequestorStack stack = RRequestorStack();
CleanupStack::PushL(TCleanupItem(CleanOp ,&stack));
CleanupStack::PushL(serviceId1);
CleanupStack::PushL(serviceId2);
CleanupStack::PushL(serviceId3);
CleanupStack::PushL(contactId1);
CleanupStack::PushL(contactId2);
CleanupStack::PushL(contactId3);
ConnectL();
OpenPositioner();
stack.Append(serviceId1);
stack.Append(contactId1);
stack.Append(contactId2);
stack.Append(serviceId2);
stack.Append(contactId3);
stack.Append(serviceId3);
CleanupStack::Pop(contactId3);
CleanupStack::Pop(contactId2);
CleanupStack::Pop(contactId1);
CleanupStack::Pop(serviceId3);
CleanupStack::Pop(serviceId2);
CleanupStack::Pop(serviceId1);
TInt err = iPositioner.SetRequestor(stack);
if (err != KErrNone)
{
_LIT(KErrorAndLeave, "Problems setting requestorstack");
LogErrorAndLeaveL(KErrorAndLeave);
}
const TInt KPosBufFlatExpandSize = 100;
//ExternalizeL
CBufFlat* bufFlat = CBufFlat::NewL(KPosBufFlatExpandSize);
CleanupStack::PushL(bufFlat);
RBufWriteStream stream(*bufFlat);
CleanupClosePushL(stream);
stack.ExternalizeL(stream);
TPtr8 dataPtr((TUint8*)NULL, 0);
dataPtr.Set(bufFlat->Ptr(0));
CleanupStack::PopAndDestroy(&stream);
HBufC8* tempBuf = HBufC8::NewLC(bufFlat->Size());
TPtr8 ptr = tempBuf->Des();
ptr = dataPtr;
//Internalize
bufFlat->InsertL(0, ptr);
RBufReadStream rstream(*bufFlat);
CleanupClosePushL(rstream);
RRequestorStack stack2 = RRequestorStack();
CleanupStack::PushL(TCleanupItem(CleanOp ,&stack2));
stack2.InternalizeL(rstream);
// Verify the requestor stack
VerifyRequestorStackL(stack2);
_LIT(KResult, "The RequestorStack is correct after Externalize/Internalize");
INFO_PRINTF1(KResult);
CleanupStack::PopAndDestroy(1); // CleanupOp stack2
CleanupStack::PopAndDestroy(&rstream);
CleanupStack::PopAndDestroy(tempBuf);
CleanupStack::PopAndDestroy(bufFlat);
CleanupStack::PopAndDestroy(1); // CleanupOp stack1
ClosePositioner();
Disconnect();
}
