/*

* Copyright (c) 2006 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:  Responsible for settings and retreiving all location 

*				 triggering settings

*

*/

// INCLUDE FILES

#include <centralrepository.h>

#include "lbtsettingsmanager.h"

#include "lbttriggeringsettingskeys.h"

#include "lbtlogger.h"

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

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

// CLbtSettingsManager::NewL

// Symbian Two - phase constructor

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

//

CLbtSettingsManager* CLbtSettingsManager::NewL()

	{

	FUNC_ENTER("CLbtSettingsManager::NewL");

	CLbtSettingsManager* self = new (ELeave) CLbtSettingsManager();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

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

// CLbtSettingsManager::ConstructL

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

//

void CLbtSettingsManager::ConstructL()

	{

	FUNC_ENTER("CLbtSettingsManager::ConstructL");

	// Create a repository object

	iRepository = CRepository::NewL(TUid::Uid(KCRUidLocationTriggeringSettings));

	// Get all the values and store it in RAM

	iRepository->Get(ELbtOptimizationLevel, iOptimizationLevel);

	iRepository->Get(ELbtModuleId, iModuleId);	

	iRepository->Get(ELbtMinUpdateInterval, iMinUpdateInterval);

	iRepository->Get(ELbtMinUpdateIntervalOnGpsFailure, iMinUpdateIntervalOnGpsFailure);

	iRepository->Get(ELbtMaxUserSpeed, iMaxUserSpeed);

	iRepository->Get(ELbtTriggeringMechanismState, iTriggeringMechanismState);

	iRepository->Get(ELbtMinimumTriggerArea, iMinimumTriggerArea);

	iRepository->Get(ELbtTrackModeInterval, iTrackModeInterval);

	iRepository->Get(ELbtLocRequestTimeOut, iLocRequestTimeOut);

	iRepository->Get(ELbtMinHysteresisArea, iMinHysteresisArea);

	iRepository->Get(ELbtDaysForCleanup, iDaysForCleanup);

	iRepository->Get(ELbtMaxActiveTriggers, iEnabledValidTriggerCount);

	iRepository->Get(ELbtNppModuleId, iNppModuleId);

	LOG1("iOptimizationLevel = %d", iOptimizationLevel);

	LOG1("iModuleId = %d", iModuleId);

	LOG1("iMinUpdateInterval = %d", iMinUpdateInterval);

	LOG1("iMinUpdateIntervalOnGpsFailure = %d", iMinUpdateIntervalOnGpsFailure);

	LOG1("iMaxUserSpeed = %d", iMaxUserSpeed);

	LOG1("iTriggeringMechanismState = %d", iTriggeringMechanismState);

	LOG1("iMinimumTriggerArea = %d", iMinimumTriggerArea);

	LOG1("iTrackModeInterval = %d", iTrackModeInterval);

	LOG1("iLocRequestTimeOut = %d", iLocRequestTimeOut);

	LOG1("iMinHysteresisArea = %d", iMinHysteresisArea);

	LOG1("iDaysForCleanup = %d", iDaysForCleanup);

	LOG1("iEnabledValidTriggerCount = %d", iEnabledValidTriggerCount);

	LOG1("iNppModuleId = %d", iNppModuleId);

	}

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

// CLbtSettingsManager::~CLbtSettingsManager

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

//

CLbtSettingsManager::~CLbtSettingsManager()

	{

	FUNC_ENTER("CLbtSettingsManager::~CLbtSettingsManager");

	delete iRepository;

	}

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

// CLbtSettingsManager::SetOptimizationLevel

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

//

void CLbtSettingsManager::SetOptimizationLevel(TInt aOptimizationLevel)

	{

	FUNC_ENTER("CLbtSettingsManager::SetOptimizationLevel");

	TInt retVal = iRepository->Set(ELbtOptimizationLevel, aOptimizationLevel);

	if(retVal == KErrNone)

		{

		iOptimizationLevel = aOptimizationLevel;

		}

	}

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

// CLbtSettingsManager::GetOptimizationLevel

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

//

TInt CLbtSettingsManager::GetOptimizationLevel()

	{

	FUNC_ENTER("CLbtSettingsManager::GetOptimizationLevel");

	return iOptimizationLevel;

	}

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

// CLbtSettingsManager::SetModuleId

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

//

void CLbtSettingsManager::SetModuleId(TPositionModuleId aModuleId)

	{

	FUNC_ENTER("CLbtSettingsManager::SetModuleId");

	TInt uid = aModuleId.iUid;

	TInt retVal = iRepository->Set(ELbtModuleId, uid);

	if(retVal == KErrNone)

		{

		iModuleId = aModuleId.iUid;

		}

	}

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

// CLbtSettingsManager::GetModuleId

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

//

TPositionModuleId CLbtSettingsManager::GetModuleId()

	{

	FUNC_ENTER("CLbtSettingsManager::GetModuleId");

	return TUid::Uid(iModuleId);

	}

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

// CLbtSettingsManager::GetNppModuleId

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

//

TPositionModuleId CLbtSettingsManager::GetNppModuleId()

	{

	FUNC_ENTER("CLbtSettingsManager::GetNppModuleId");

	return TUid::Uid(iNppModuleId);

	}

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

// CLbtSettingsManager::SetMinimumUpdateInterval

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

//

void CLbtSettingsManager::SetMinimumUpdateInterval(TInt aUpdateInterval)

	{

	FUNC_ENTER("CLbtSettingsManager::SetMinimumUpdateInterval");

	TInt retVal = iRepository->Set(ELbtMinUpdateInterval, aUpdateInterval);

	if(retVal == KErrNone)

		{

		iMinUpdateInterval = aUpdateInterval;

		}

	}

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

// CLbtSettingsManager::GetMinimumUpdateInterval

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

//

TInt CLbtSettingsManager::GetMinimumUpdateInterval()

	{

	FUNC_ENTER("CLbtSettingsManager::GetMinimumUpdateInterval");

	return iMinUpdateInterval;

	}

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

// CLbtSettingsManager::SetMinimumUpdateIntervalOnGpsFailure

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

//

void CLbtSettingsManager::SetMinimumUpdateIntervalOnGpsFailure(TInt aUpdateInterval)

	{

	FUNC_ENTER("CLbtSettingsManager::SetMinimumUpdateIntervalOnGpsFailure");

	TInt retVal = iRepository->Set(ELbtMinUpdateIntervalOnGpsFailure, aUpdateInterval);

	if(retVal == KErrNone)

		{

		iMinUpdateIntervalOnGpsFailure = aUpdateInterval;

		}

	}

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

// CLbtSettingsManager::GetMinimumUpdateIntervalOnGpsFailure

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

//

TInt CLbtSettingsManager::GetMinimumUpdateIntervalOnGpsFailure()

	{

	FUNC_ENTER("CLbtSettingsManager::GetMinimumUpdateIntervalOnGpsFailure");

	return iMinUpdateIntervalOnGpsFailure;

	}

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

// CLbtSettingsManager::SetMaximumUserSpeed

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

//

void CLbtSettingsManager::SetMaximumUserSpeed(TInt aSpeed)

	{

	FUNC_ENTER("CLbtSettingsManager::SetMaximumUserSpeed");

	TInt retVal = iRepository->Set(ELbtMaxUserSpeed, aSpeed);

	if(retVal == KErrNone)

		{

		iMaxUserSpeed = aSpeed;

		}

	}

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

// CLbtSettingsManager::GetMaximumUserSpeed

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

//

TInt CLbtSettingsManager::GetMaximumUserSpeed()

	{

	FUNC_ENTER("CLbtSettingsManager::GetMaximumUserSpeed");

	return iMaxUserSpeed;

	}

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

// CLbtSettingsManager::SetTriggeringMechanismState

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

//

void CLbtSettingsManager::SetTriggeringMechanismState(TLbtTriggeringMechanismState aState)

	{

	FUNC_ENTER("CLbtSettingsManager::SetTriggeringMechanismState");

	TInt retVal = iRepository->Set(ELbtTriggeringMechanismState, aState);

	if(retVal == KErrNone)

		{

		iTriggeringMechanismState = aState;

		}

	}

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

// CLbtSettingsManager::GetTriggeringMechanismState

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

//

TInt CLbtSettingsManager::GetTriggeringMechanismState()

	{

	FUNC_ENTER("CLbtSettingsManager::GetTriggeringMechanismState");

	return iTriggeringMechanismState;

	}

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

// CLbtSettingsManager::MinimumTriggeringArea

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

//

TInt CLbtSettingsManager::MinimumTriggeringArea()

	{

	FUNC_ENTER("CLbtSettingsManager::MinimumTriggeringArea");

	return iMinimumTriggerArea;

	}

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

// CLbtSettingsManager::TrackingModeInterval

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

//

TInt CLbtSettingsManager::TrackingModeInterval()

	{

	FUNC_ENTER("CLbtSettingsManager::TrackingModeInterval");

	return iTrackModeInterval;

	}

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

// CLbtSettingsManager::GetLocationRequestTimeOut

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

//

TInt CLbtSettingsManager::GetLocationRequestTimeOut()

	{

	FUNC_ENTER("CLbtSettingsManager::GetLocationRequestTimeOut");

	return iLocRequestTimeOut;

	}

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

// CLbtSettingsManager::MinimumHysteresisArea

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

//

TInt CLbtSettingsManager::MinimumHysteresisArea()

	{

	FUNC_ENTER("CLbtSettingsManager::MinimumHysteresisArea");

	return iMinHysteresisArea;

	}

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

// CLbtSettingsManager::NumberOfDaysForCleanup

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

//

TInt CLbtSettingsManager::NumberOfDaysForCleanup()

	{

	FUNC_ENTER("CLbtSettingsManager::NumberOfDaysForCleanup");

	return iDaysForCleanup;

	}

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

// CLbtSettingsManager::NumberOfDaysForCleanup

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

//

TInt CLbtSettingsManager::EnabledValidTriggerCount()

	{

	return iEnabledValidTriggerCount;

	}

// end of file