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