// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

// INCLUDE FILES

#include "ctlbsclientpostp254.h"

#include <f32file.h>

#include <bautils.h>

#include <lbssatellite.h>

// CONSTANTS

_LIT(KLastPosition, "c:\\private\\101f97b2\\LastKnownPos.dat");

// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------

// Constructor.

// ---------------------------------------------------------

CT_LbsClientPosTp254::CT_LbsClientPosTp254(CT_LbsServer& aParent): CT_LbsPortedStepBase(aParent)

	{  

	_LIT(KTestName, "TP254 - Get last known position");

	SetTestStepName(KTestName); 

	}

// ---------------------------------------------------------

// Destructor.

// ---------------------------------------------------------

CT_LbsClientPosTp254::~CT_LbsClientPosTp254()

	{

	}

// ---------------------------------------------------------

// CT_LbsClientPosTp254::CloseTest

//

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CT_LbsClientPosTp254::CloseTest()

    {

    }

// ---------------------------------------------------------

// CT_LbsClientPosTp254::StartL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CT_LbsClientPosTp254::StartL()

    {

    User::After(2000000);

	SetupPsyL(iUidTestPsy11);

    RPositionServer	posServer;

    CleanupClosePushL(posServer);

    RPositioner positioner;

    CleanupClosePushL(positioner);

    TPositionInfo positionInfo = TPositionInfo();

    TPositionInfo positionInfoLast = TPositionInfo();

	_LIT(KConnectErr, "Error when connecing to EPos server,  %d");

	TInt err = posServer.Connect();

	AssertTrueL(err == KErrNone, KConnectErr, err);

    TRequestStatus clearDbReqStatus;

    posServer.EmptyLastKnownPositionStore(clearDbReqStatus);

    User::WaitForRequest(clearDbReqStatus);

    _LIT(KClearoutErr, "Error when clearing out last known position via api on session, error code returned was %d");

    AssertTrueL(clearDbReqStatus.Int() == KErrNone, KClearoutErr, clearDbReqStatus.Int());

	_LIT(KOpenErr, "Error when opening positioner,  %d");

    err = positioner.Open(posServer,iUidTestPsy11 ); //use defalut psy

	AssertTrueL(err == KErrNone, KOpenErr, err);

    _LIT(KService ,"Service");

	positioner.SetRequestor(CRequestor::ERequestorService,

							 CRequestor::EFormatApplication, KService);

    TRequestStatus status;

    status = KRequestPending;

    positionInfoLast.SetUpdateType(EPositionUpdateUnknown); // just to make a difference

    positioner.GetLastKnownPosition(positionInfoLast, status);

    User::WaitForRequest(status);

    err = status.Int();

    _LIT(KErrorRequest, "Get last known position did not return with KErrUnKnown %d");

    AssertTrueL(err == KErrUnknown, KErrorRequest, err);

    //Verification of TR SBUY-5WHGS3 i.e even if the psy has a really fast

    //responce time a last known position should be saved.

    status = KRequestPending;

    positioner.NotifyPositionUpdate(positionInfo, status);

    User::WaitForRequest(status);

    err = status.Int();

    _LIT(KErrPosition, "Not possible to make a request");

    AssertTrueL(err == KErrNone, KErrPosition, err);

    positioner.GetLastKnownPosition(positionInfoLast, status);

    User::WaitForRequest(status);

    err = status.Int();

    _LIT(KErrorFast, "Get last known position after fast psy did not work %d");

    AssertTrueL(err == KErrNone, KErrorFast, err);

    positioner.Close();

    clearDbReqStatus = KRequestPending;

    posServer.EmptyLastKnownPositionStore(clearDbReqStatus);

    User::WaitForRequest(clearDbReqStatus);

    posServer.Close();

    const TTimeIntervalMicroSeconds32 KPosWaitServerShutDown( 6000000 );

    User::After(KPosWaitServerShutDown);

    SetupPsyL(iUidTestPsyMaxAge);

	err = posServer.Connect();

	AssertTrueL(err == KErrNone, KConnectErr, err);

    err = positioner.Open(posServer); //use defalut psy

	AssertTrueL(err == KErrNone, KOpenErr, err);

	positioner.SetRequestor(CRequestor::ERequestorService,

							 CRequestor::EFormatApplication, KService);

    status = KRequestPending;

    positioner.NotifyPositionUpdate(positionInfo, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrPosition, err);

    //Now there should exist a last known position

    positioner.GetLastKnownPosition(positionInfoLast, status);

    User::WaitForRequest(status);

    err = status.Int();

    _LIT(KErrorRequestLast, "Get last known position did not return with KErrNone %d");

    AssertTrueL(err == KErrNone, KErrorRequestLast, err);

    CheckPositionInfoL(positionInfo, positionInfoLast);

	TPositionSatelliteInfo satelliteInfoLast = TPositionSatelliteInfo();

    positioner.GetLastKnownPosition(satelliteInfoLast, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrArgument, KErrorRequest, err);

    positioner.NotifyPositionUpdate(positionInfo, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrPosition, err);

    positioner.GetLastKnownPosition(positionInfoLast, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrorRequest, err);

    CheckPositionInfoL(positionInfo, positionInfoLast);

    positioner.Close();

    posServer.Close();

    //connect again

	err = posServer.Connect();

	AssertTrueL(err == KErrNone, KConnectErr, err);

    err = positioner.Open(posServer); //use defalut psy

	AssertTrueL(err == KErrNone, KOpenErr, err);

	positioner.SetRequestor(CRequestor::ERequestorService,

							 CRequestor::EFormatApplication, KService);

    TPositionInfo positionInfoLast1 = TPositionInfo();

    positioner.GetLastKnownPosition(positionInfoLast1, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrorRequest, err);    

    CheckPositionInfoL(positionInfoLast, positionInfoLast1);

    positioner.Close();

    posServer.Close();

	User::After(6000000);

	// Old DB file will never be present

    //Connect again

	err = posServer.Connect();

	AssertTrueL(err == KErrNone, KConnectErr, err);

    err = positioner.Open(posServer); //use defalut psy

	AssertTrueL(err == KErrNone, KOpenErr, err);

	positioner.SetRequestor(CRequestor::ERequestorService,

							 CRequestor::EFormatApplication, KService);

    TPositionInfo positionInfoLast2 = TPositionInfo();

    positioner.GetLastKnownPosition(positionInfoLast2, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrorRequest, err);    

    CheckPositionInfoL(positionInfoLast, positionInfoLast2);

    RPositionServer	posServer1;

    CleanupClosePushL(posServer1);

    RPositioner positioner1;

    CleanupClosePushL(positioner1);

    SetupPsyL(iUidMultiPsy);

	_LIT(KConnect1Err, "Error when connecing to EPos server,  %d");

	err = posServer1.Connect();

	AssertTrueL(err == KErrNone, KConnect1Err, err);

	_LIT(KOpen1Err, "Error when opening positioner,  %d");

    err = positioner1.Open(posServer); //use defalut psy

	AssertTrueL(err == KErrNone, KOpen1Err, err);

	positioner1.SetRequestor(CRequestor::ERequestorService,

							 CRequestor::EFormatApplication, KService);

    positioner1.NotifyPositionUpdate(positionInfo, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrPosition, err);

    positioner.GetLastKnownPosition(positionInfoLast, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrorRequest, err);

    CheckPositionInfoL(positionInfo, positionInfoLast);

    //just to make sure that positioner1 also gets the correct position

    positioner1.GetLastKnownPosition(positionInfoLast, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrorRequest, err);

    CheckPositionInfoL(positionInfo, positionInfoLast);

    SetupPsyL(iUidTestPsyPartialUpdate);

    User::After(1000000);

    TPositionInfo positionInfoPartial = TPositionInfo();

    TPositionUpdateOptions updateOption = TPositionUpdateOptions();

    updateOption.SetAcceptPartialUpdates(ETrue);

    positioner1.SetUpdateOptions(updateOption);

    positioner1.NotifyPositionUpdate(positionInfoPartial, status);

    User::WaitForRequest(status);

    err = status.Int();

    _LIT(KErrPositionPartial, "no partial position returned %d");

    AssertTrueL(err == KPositionPartialUpdate, KErrPositionPartial, err);

    positioner.GetLastKnownPosition(positionInfoLast, status);

    User::WaitForRequest(status);

    err = status.Int();

    AssertTrueL(err == KErrNone, KErrorRequest, err);

    TPosition pos;

    TPosition lastPos;

	positionInfoPartial.GetPosition(pos);

    positionInfoLast.GetPosition(lastPos);

    if (pos.Time() == lastPos.Time())

		{

		_LIT(KErrPosition, "Partial position was cached");

		LogErrorAndLeaveL(KErrPosition);

		}

    CleanupStack::PopAndDestroy(&positioner1);

    CleanupStack::PopAndDestroy(&posServer1);

    CleanupStack::PopAndDestroy(&positioner);

    CleanupStack::PopAndDestroy(&posServer);

    }

// ---------------------------------------------------------

// CT_LbsClientPosTp254::DeleteFileL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CT_LbsClientPosTp254::DeleteFileL(const TDesC& aFile)

    {

    RFs fs;

    TInt err = fs.Connect();

    err = fs.Delete(aFile);

    fs.Close();

    if (err == KErrNone)

        {

        _LIT(KDebugText, "TP254: The specified file deleted");

        INFO_PRINTF1(KDebugText);

        }

    else

        {

        if (err == KErrInUse)

            {

            _LIT(KErrText, "TP254: The specified file could not be deleted it is already in use, errorcode %d");

            INFO_PRINTF1(aFile);

            TBuf<100> buf;

            buf.Format(KErrText, err);

            AssertTrueL(err==0, KErrText, err);

            }

        else if (err == KErrNotFound)

            {

            _LIT(KDebugText, "TP254: The specified file could not be found ,errorcode %d");

            TBuf<100> buf;

            buf.Format(KDebugText, err);

            INFO_PRINTF1(buf);

            }

        else if (err == KErrPathNotFound)

            {

            _LIT(KDebugText, "TP254: The path could not be found ,errorcode %d");

            TBuf<100> buf;

            buf.Format(KDebugText, err);

            INFO_PRINTF1(buf);

            }

        else

            {

            _LIT(KErrText, "TP254: The specified file could not be deleted, errorcode %d");

            TBuf<100> buf;

            buf.Format(KErrText, err);

            AssertTrueL(err==0, KErrText, err);

            }

        }

    }

// ---------------------------------------------------------

// CT_LbsClientPosTp254::FileExistsL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//

TBool CT_LbsClientPosTp254::FileExistsL(const TDesC& aFile)

    {

    RFs fs;

    TInt err = fs.Connect();

    TBool exists = EFalse;

    if(KErrNone==err)

    	{

    	exists = BaflUtils::FileExists(fs, aFile);

    	if (exists)

    		{

    		_LIT(KErrText, "TP254: The specified file does not exist");

    		INFO_PRINTF1(KErrText);

    		}

    	else

    		{

    		_LIT(KErrText, "TP254: The specified file exists");

    		INFO_PRINTF1(KErrText);

    		}

    	}

    fs.Close();

    return exists;

    }

void CT_LbsClientPosTp254::CheckPositionInfoL(TPositionInfo& aInfo, TPositionInfo& aLastInfo)

	{

    if (aInfo.UpdateType() != aLastInfo.UpdateType())

        {

        _LIT(KErrUpdateType, "Update type not stored correctly");

        LogErrorAndLeaveL(KErrUpdateType);

        }

    if (aLastInfo.ModuleId().iUid != 0)

		{

		_LIT(KIncorrectPsyError,

           "Uid not reseted");

		LogErrorAndLeaveL(KIncorrectPsyError);

		}

	TPosition pos;

    TPosition lastPos;

	aInfo.GetPosition(pos);

    aLastInfo.GetPosition(lastPos);

	CheckPositionL(pos, lastPos);

	}

void CT_LbsClientPosTp254::CheckPositionL(TPosition& aPos, TPosition& aLastPos)

	{

	if (aPos.Time() != aLastPos.Time() ||

		aPos.HorizontalAccuracy() != aLastPos.HorizontalAccuracy() ||

		aPos.VerticalAccuracy() != aLastPos.VerticalAccuracy() ||

		aPos.Latitude() != aLastPos.Latitude() ||

		aPos.Longitude() != aLastPos.Longitude() ||

		aPos.Altitude() != aLastPos.Altitude())

		{

		_LIT(KErrPosition, "Wrong position returned");

		LogErrorAndLeaveL(KErrPosition);

		}

	}

// End of File