/*

* Copyright (c) 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 "EPos_CPosControllerManager.h"

#include <e32debug.h> 

#include <f32file.h>

#include <e32std.h>

#include <centralrepository.h>

#include "EPos_CPosSimulationPositioner.h"

#include "EPos_CPosControllerBase.h"

#include "SimulationPSYInternalCRKeys.h"

#include "EPos_CPosNmeaController.h"

#include "EPos_CPosFixedDataController.h"

#include "EPos_CPosDataSimulationController.h"

_LIT(KDefaultNmeFileName, "\\resource\\default.nme");

// The unit tests (te_lbssimulationsuite.exe) are built as an EXE and cannot 

// use TLS.  The macro below redefines Dll to a new class TestDll that provides 

// an EXE equivalent.

#ifdef SIMPSYTEST

#define Dll TestDll

class TestDll

	{

public:

	static TAny* Tls() { return reinterpret_cast<TAny*>(iInternal); };

	static TInt SetTls(const TAny* aAny) 

		{ 

		iInternal = reinterpret_cast<TUint32>(aAny); 

		return KErrNone;

		};

	static void FreeTls() { iInternal = 0; };

private:

	static TUint32 iInternal;

	};

TUint32 TestDll::iInternal = 0;

#endif

TUint32 HashFunc(const CPosSimulationPositioner& aSimPos)

	{

	return DefaultHash::Integer(reinterpret_cast<TInt>(&aSimPos));

	}

TBool IdentityFunc(const CPosSimulationPositioner& aSimPos1, const CPosSimulationPositioner& aSimPos2)

	{

	return &aSimPos1 == &aSimPos2;

	}

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

// Returns the singleton instance.

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

//

CPosControllerManager* CPosControllerManager::InstanceL()

	{

	CPosControllerManager* self = NULL;

	TAny* tlsPtr = Dll::Tls();

	if (!tlsPtr)

		{

		self = new (ELeave) CPosControllerManager;

		CleanupStack::PushL(self);

		self->ConstructL();

		User::LeaveIfError(Dll::SetTls(self));

		CleanupStack::Pop(self);

		}

	else

		{

		self = static_cast<CPosControllerManager*> (tlsPtr);

		++self->iReferenceCount;

		}

	return self;

	}

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

// Releases the singleton instance.

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

//

void CPosControllerManager::ReleaseInstance(const CPosSimulationPositioner& aSimPos)

	{

	//Delete controller only in Independent Data Set mode.

	//when there is more then one controller

	//In TRP mode the only existing controller is deleted in destructor

	if (!iTrp)

		{

		CPosControllerBase* p = iPositionerControllerMap.Find(aSimPos);

		delete p;

		iPositionerControllerMap.Remove(&aSimPos);

		}

	TAny* tlsPtr = Dll::Tls();

	__ASSERT_DEBUG( tlsPtr, User::Panic(

					_L( "CPosControllerManager" ), KErrNotFound ) );

	CPosControllerManager* self = static_cast<CPosControllerManager*> (tlsPtr);

	if (--self->iReferenceCount == 0)

		{

		Dll::FreeTls();

		delete self;

		}

	}

CPosControllerManager::CPosControllerManager() :

	iReferenceCount(1),

	iPositionerControllerMap(THashFunction32<CPosSimulationPositioner>(&HashFunc), TIdentityRelation<CPosSimulationPositioner>(&IdentityFunc))

	{

	iLastFixIsPartial = EFalse; 

	}

void CPosControllerManager::ConstructL()

	{

	iTrp = RepositoryTrpValueL();

	}

/**

 * Private destructor so users cannot directly delete this instance.

 * They must call ReleaseInstance()

 */

CPosControllerManager::~CPosControllerManager()

	{

	iPositionerControllerMap.Close();

	if (iTrpController && iTrp)

		{

		delete iTrpController;

		}

	}

/**

 * Check in central repository if time relative playback (TRP) in on.

 * @return ETrue if TRP is on, EFalse if it's off.

 */

TBool CPosControllerManager::RepositoryTrpValueL()

	{

	TInt val = 0;

	CRepository* repository = CRepository::NewLC(KCRUidSimulationPSY);

	User::LeaveIfError( repository->Get(KCRKeySimPSYCommonDataSet, val) );

	CleanupStack::PopAndDestroy(repository);

	return static_cast<TBool>(val);

	}

CPosControllerBase& CPosControllerManager::ControllerL(

		const CPosSimulationPositioner& aSimPos)

	{

	CPosControllerBase* p = NULL;

	if(!iTrp)

		{

		p = iPositionerControllerMap.Find(aSimPos);

		}

	else

		{

		p = iTrpController;

		}

	//if there is no controller associated with give positioner

	//just create new one

	if(!p)

		{

		p = CreateControllerL(aSimPos);

		//in Time Relative Playback we should have only one controller

		//in old mode we need to create each time new one.

		if (iTrp)

			{

			iTrpController = p;

			}

		}

	return *p;

	}

/**

 * Create controller and pairs it with given CPosSimulationPositioner 

 * Controller type is determined by filename given in central repository.

 * @param aSimPos Pointer to positioner that will be connecter with new controller

 */

CPosControllerBase* CPosControllerManager::CreateControllerL(const CPosSimulationPositioner& aSimPos)

	{

	CPosControllerBase* retController = NULL;

	//getting file name from repository

	TFileName fileName;

	CRepository* repository = CRepository::NewLC(KCRUidSimulationPSY);

	User::LeaveIfError(repository->Get(KCRKeySimPSYSimulationFile, fileName));

	CleanupStack::PopAndDestroy(repository);

	fileName.LowerCase();

	TParsePtrC fileNamePtr(fileName);

	//based on file extension creating correct type controller

	TInt err = KErrNone;

	if (fileNamePtr.Ext().Compare(KPosNMEAFileExtension) == 0)

		{

			TRAP(err, retController =

					CPosNmeaController::NewL(fileName, iTrp));

		}

	else if (fileNamePtr.Ext().Compare(KPosSimulationFileExtension) == 0)

		{

			TRAP(err, retController =

					CPosDataSimController::NewL(fileName, iTrp));

		}

	else if (fileName.Length() == 0)

		{

		// No file selected so use the default.nme file from

		// \resource directory

		TFileName DllName;

		TParse nmeFileName;

#ifndef SIMPSYTEST

		Dll::FileName(DllName);

#else

		_LIT(KTestPathTxt, "Z:\\resource\\");

		DllName.Copy(KTestPathTxt);

#endif

		nmeFileName.Set(KDefaultNmeFileName, &DllName, NULL);

			TRAP(err, retController =

					CPosNmeaController::NewL(nmeFileName.FullName(), iTrp));

		if (err == KErrPathNotFound || err == KErrNotFound 

				|| err == KErrCorrupt)

			{

				TRAP(err, retController = CPosFixedDataController::NewL());

			}

		}

	else

		{

		err = KErrNotSupported;

		}

	User::LeaveIfError(err);

	//after valid controller creation adding it to map of positioners 

	//and controllers to be able then properly delete it when it will be unneeded

	if(!iTrp)

		{

		iPositionerControllerMap.InsertL(&aSimPos, retController);

		}

	return retController;

	}

TPositionInfo& CPosControllerManager::GetLastFix()

	{

	return iLastFix;

	}

void CPosControllerManager::SetLastFix(TPositionInfo& aPosInfo)

	{

	iLastFix = aPosInfo;

	}

TBool CPosControllerManager::GetLastFixIsPartial()

	{

	return iLastFixIsPartial;

	}

void CPosControllerManager::SetLastFixIsPartial(TBool aPartial)

	{

	iLastFixIsPartial = aPartial;

	}