// Copyright (c) 2007-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 "sysconfigimpl.h"

 #include <hal.h>

 #include <hal_data.h>

 using namespace BSUL;

 namespace Ulogger

 {

 //////////////////////////////////////////////////////////////////////////////

 CConfigSettingsImpl* CConfigSettingsImpl::NewL()

 	{

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

 	return self;

 	}

 TBool CConfigSettingsImpl::Next(TPtrC8& aSetting,TPtrC8& aSettingValue)

 	{

 	if (!iIniSecIter)

 		{

 		return EFalse;

 		}

 	return iIniSecIter->Next(aSetting,aSettingValue);	

 	}

 void CConfigSettingsImpl::Reset()

 	{	

 	if (iIniSecIter)

 		{

 		iIniSecIter->Reset();

 		}

 	}

 CConfigSettingsImpl::~CConfigSettingsImpl()

 	{

 	if (iIniSecIter)

 		{

 		delete iIniSecIter;

 		iIniSecIter=NULL;			

 		}

 	}

 CConfigSettingsImpl::CConfigSettingsImpl():iIniSecIter(NULL)

 	{

 	}	

 ///////////////////////////////////////////////////////////////////////////////

 CConfigImpl* CConfigImpl::NewL(RHeap* aHeap,TFileName& aFileName)

 	{

 	CConfigImpl* self=new (ELeave)CConfigImpl(aHeap,aFileName);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 void CConfigImpl::ConstructL()

 	{

 	// Create/open a handle onto global mutex used to protect

 	// access to the config file.

 	TInt ret = KErrAlreadyExists;

 	for ( ; ret==KErrAlreadyExists; )

 		{

 		ret = iWriteMutex.OpenGlobal(KSysConfigMutex, EOwnerProcess);

 		if (ret == KErrNotFound)

 			ret = iWriteMutex.CreateGlobal(KSysConfigMutex, EOwnerProcess);

 		}

 	User::LeaveIfError(ret);

 	//establishing connection to file server

 	User::LeaveIfError(iFs.Connect());

 	// allow this connection to be shared with other threads

 	// - this facilitates sharing of config objects between threads

 	User::LeaveIfError(iFs.ShareProtected());

 	// load config

 //	iIniFileWatcher = NULL;

 	LoadConfigFileL();

 	}

 CConfigImpl::~CConfigImpl()

 	{

 	if (iIniFileDocument)

 		{

 		delete iIniFileDocument;

 		iIniFileDocument=NULL;

 		}	

 	//closing the mutex

 	if (iWriteMutex.Handle() && iWriteMutex.IsHeld())

 		{

 		iWriteMutex.Signal();

 		}

 	iWriteMutex.Close();

 	//closing the file handle

 	iFs.Close();	

 	}

 /**

 Load the Ulogger config file contents.

 The existing iIniFileDocument and caches are cleared.

 This method assumes that iFs is connected. 

 */

 void CConfigImpl::LoadConfigFileL()

 	{

 	//switch to private heap

 	RHeap* threadHeap = NULL;

 	if (iHeap)

 		threadHeap = User::SwitchHeap(iHeap);		

 	// delete existing document

 	if (iIniFileDocument)

 		{

 		delete iIniFileDocument;

 		iIniFileDocument=NULL;

 		}

 	TEntry dummy;

 	TInt ret=iFs.Entry(iFileName,dummy);

 	// grab the mutex

 	iWriteMutex.Wait();

 	//Creating an instance of IniDocument from default

 	iIniFileDocument=CIniDocument8::NewL(iFs,iFileName);

 	// release the mutex

 	iWriteMutex.Signal();

 	//switch back to user heap

 	if (threadHeap)

 		User::SwitchHeap(threadHeap);

 	}

 TInt CConfigImpl::PersistIniFile()

 	{

 	// grab the mutex

 	iWriteMutex.Wait();

 	TInt ret=iIniFileDocument->Externalise(iFileName);	

 	// release the mutex

 	iWriteMutex.Signal();

 	return ret;

 	}	

 TInt CConfigImpl::GetKeyValue(const TDesC8& aSectionName,const TDesC8& aKeyName ,TPtrC8& aValue)

 	{

 	return iIniFileDocument->GetKeyValue(aSectionName,aKeyName,aValue);

 	}

 TInt CConfigImpl::RemoveKey(const TDesC8& aSectionName,const TDesC8& aKeyName)

 	{

 	return iIniFileDocument->RemoveKey(aSectionName,aKeyName);

 	}

 TInt CConfigImpl::SetKeyValue(const TDesC8& aSectionName,const TDesC8& aKey, const TDesC8& aValue)

 	{

 	return iIniFileDocument->SetKey(aSectionName,aKey,aValue);

 	}

 /*TInt CConfigImpl::AddSection(const TDesC8& aSectionName)

 	{

 	return iIniFileDocument->AddSection(aSectionName);

 	}*/

 TInt CConfigImpl::RemoveSection(const TDesC8& aSectionName)

 	{

 	return iIniFileDocument->RemoveSection(aSectionName);

 	}

 TInt CConfigImpl::GetSection(const TDesC8& aSectionName,CConfigSettingsIter& aSection)

 	{

 	//clear any previous internal iIniSecIterator

 	if (aSection.iImpl->iIniSecIter)

 		{

 		delete (aSection.iImpl->iIniSecIter);

 		aSection.iImpl->iIniSecIter=NULL;

 		}

 	//initializing its internal iIniSecIterator

 	TRAPD(ret,aSection.iImpl->iIniSecIter=CIniSecIter8::NewL(aSectionName,iIniFileDocument));

 	return ret;	

 	}

 //util to check any key within that section holds that value

 //if not found simply return the number of keys within that section

 TInt CConfigImpl::CheckValueExist(const TDesC8& aSectionName,const TDesC8& aValue,TInt& aKeyCount)

 	{

 	CIniSecIter8* iter=NULL;

 	TRAPD(err,iter=CIniSecIter8::NewL(aSectionName,iIniFileDocument));

 	//if section not found it might be the first time we are creating

 	//the document so it is fine to return KErrNone

 	if (err==KErrNotFound)

 		{

 		return KErrNone;

 		}

 	//return the error code if else than KErrNotFound e.g. KErrNoMemory;

 	if (err!=KErrNone)

 		{

 		return err;

 		}

 	TPtrC8 key;

 	TPtrC8 value;

 	TInt keyCount=0;

 	while (iter->Next(key,value))

 		{

 		if (value.Compare(aValue)==0)

 			{

 			delete iter;

 			keyCount=0;

 			return KErrAlreadyExists;

 			}

 		keyCount++;	 	

 		}

 	aKeyCount=keyCount;

 	delete iter;	

 	return KErrNone;	

 	}

 TInt CConfigImpl::GenerateInternalKey(const TDesC8& aSection,TBuf8<15>& aKeyName)

 	{

 	TPtrC8 lastKey;

 	TInt ret=GetKeyCount(aSection,lastKey);

 	if (ret<0)

 		{

 		return ret;		

 		}

 	//either "mediaX" or "X"

 	//TInt key=ret;

 	if(aSection.Compare(KPrimaryFilterSection)== 0 ) 

 	{

 		TInt lastKeyValue=0;

 		if(lastKey.Length())

 			{

 			TLex8 lex(lastKey);

 			TInt err = lex.Val(lastKeyValue);

 			if(err != KErrNone)

 				return err;

 			}

 		aKeyName.Format(_L8("%03d"),++lastKeyValue);

 	}

 	else if(aSection.Compare(KSecondaryFilterSection) == 0)

 	{

 		TInt lastKeyValue=0;

 		if(lastKey.Length())

 			{

 			TLex8 lex(lastKey);

 			TInt err = lex.Val(lastKeyValue);

 			if(err != KErrNone)

 				return err;

 			}

 		aKeyName.Format(_L8("%04d"),++lastKeyValue);

 	}

 	else

 	{

 		TInt lastKeyValue=0;

 		if(lastKey.Length())

 			{

 			TLex8 lex(lastKey);

 			TInt err = lex.Val(lastKeyValue);

 			if(err != KErrNone)

 				return err;

 			}

 		aKeyName.Format(_L8("%d"),++lastKeyValue);

 	}	

 	return KErrNone;	

 }

 /*TInt CConfigImpl::GenerateInternalSessionName(const TDesC8& aSection,TBuf8<15>& aKeyName)

 	{

 	TPtrC8 lastKey;

 	TInt ret=GetKeyCount(aSection,lastKey);

 	if (ret<0)

 		{

 		return ret;		

 		}

 	//either "mediaX" or "X"

 	TInt index=(aSection.Compare(KActiveSection)==0?5:0);

 	TInt key=0;

 	if (lastKey.Length()!=0)

 		{

 		TLex8 lex;		

 		lex.Assign(lastKey.Mid(index));

 		lex.Val(key);

 		}

 	aKeyName.Format((aSection.Compare(KActiveSection)==0?_L8("Session%d"):_L8("%d")),++key);	

 	return KErrNone;	

 	}*/

 TInt CConfigImpl::GetKeyCount(const TDesC8& aSectionName,TPtrC8& aLastKey)

 	{

 	CIniSecIter8* iter=NULL;

 	TRAPD(err,iter=CIniSecIter8::NewL(aSectionName,iIniFileDocument));

 	//if section not found it indicates the keycount is 0;

 	if (err==KErrNotFound)

 		{

 		return 0;			

 		}

 	//return any error code e.g KErrNoMemory here;

 	if (err!=KErrNone)

 		{

 		return err;		

 		}

 	TPtrC8 key;

 	TInt keyCount=0x0000;

 	while (iter->Next(aLastKey,key))

 		{	

 		keyCount++;

 		}

 	delete iter;

 	return keyCount;

 	}

 TInt CConfigImpl::GetPointerToKeyName(const TDesC8& aSectionName,const TDesC8& aKeyName,TPtrC8& aKeyPointer)

 	{

 	CIniSecIter8* iter=NULL;

 	TRAPD(err,iter=CIniSecIter8::NewL(aSectionName,iIniFileDocument));

 	if (err!=KErrNone)

 		{

 		return err;		

 		}

 	TPtrC8 value;

 	while (iter->Next(aKeyPointer,value))

 		{

 		if (aKeyName.Compare(aKeyPointer)==0)

 			{

 			delete iter;

 			return KErrNone;

 			}

 		}

 	delete iter;	

 	return KErrNotFound;

 	}	

 }