// Copyright (c) 2005-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 <e32base.h>

#include <s32mem.h>

#include <centralrepository.h>

#include <coemain.h>

#include "CoeDataStorage.h"

#include <coedef.h>

#include <gulcolor.h>

#include <barsread.h>

#include "coepanic.h"

#include <bautils.h>

#include "coedefkeys.h"

const TUint KUidSystemColorRepository=0x10272619;

const TUint KSystemColorRepositoryKey=0;

const TInt KColorListBufferGranularity=1024;

const TUint KUidFepSpecificSettingsRepository=0x10009793; // also defined in fepbase\source\Fepbase.cpp

// CCoeDataStorage

EXPORT_C CCoeDataStorage& CCoeDataStorage::GetL(CCoeEnv& aCoeEnv)

	{ // static

	COwner* owner=STATIC_CAST(COwner*, aCoeEnv.FindStatic(TUid::Uid(COwner::ECoeStaticUid)));

	if (owner==NULL)

		{

		CCoeDataStorage* const dataStorage=NewL();

		CleanupStack::PushL(dataStorage);

		owner=new(ELeave) COwner(dataStorage);

		CleanupStack::Pop(dataStorage);

		}

	return *owner->DataStorage();

	}

EXPORT_C CCoeDataStorage* CCoeDataStorage::NewL()

	{ // static

	return new(ELeave) CCoeDataStorage;

	}

EXPORT_C CCoeDataStorage::~CCoeDataStorage()

	{

	delete iFepFrameworkRepository;

	delete iFepSpecificSettingsRepository;

	delete iSystemColorListRepository;

	}

EXPORT_C void CCoeDataStorage::GetInstalledFepIdL(TDes& aFepId)

	{

	CRepository& repository=FepFrameworkRepositoryL();

	if (repository.Get(ERepositoryKey_DynamicFepId, aFepId)!=KErrNone)

		{

		User::LeaveIfError(repository.Get(ERepositoryKey_DefaultFepId, aFepId));

		}

	}

EXPORT_C void CCoeDataStorage::SetInstalledFepIdL(const TDesC& aFepId)

	{

	User::LeaveIfError(FepFrameworkRepositoryL().Set(ERepositoryKey_DynamicFepId, aFepId));

	}

EXPORT_C void CCoeDataStorage::GetFepAttributeL(TUid aAttributeUid, TDes8& aAttributeData)

	{

	CRepository& repository=FepSpecificSettingsRepositoryL();

	User::LeaveIfError(repository.Get(aAttributeUid.iUid, aAttributeData));

	}

EXPORT_C void CCoeDataStorage::SetFepAttributeL(TUid aAttributeUid, const TDesC8& aAttributeData)

	{

	User::LeaveIfError(FepSpecificSettingsRepositoryL().Set(aAttributeUid.iUid, aAttributeData));

	}

/** This method will return a new CColorList object poplulated with the color information

read from a configuration ini-file. If the ini-file cannot be found, this method will return NULL, 

in which case the color list should be read from resource file. This is the action taken by PopulateColorArrayL(). */

EXPORT_C CColorList* CCoeDataStorage::GetSystemColorListL()

	{

	TBool doesExist = EFalse;

	CBufFlat* const buffer = GetSystemColorListBufferLC(doesExist);

	CColorList* colorList = NULL;

	if (doesExist)

		{

		colorList=CColorList::NewLC();

		RBufReadStream readStream(*buffer);

		TRAPD(err,colorList->InternalizeL(readStream));

		CleanupStack::Pop(colorList);

		if (err != KErrNone)

			{

			delete colorList;

			colorList=NULL;

			}

		}

	CleanupStack::PopAndDestroy(buffer);

	return colorList;

	}

EXPORT_C CBufBase* CCoeDataStorage::GetSystemColorListBufferL()

	{

	TBool exists=EFalse;

	CBufFlat* const buffer=GetSystemColorListBufferLC(exists);

	if (!exists)

		{

		buffer->Reset();

		}

	CleanupStack::Pop(buffer);

	return buffer;

	}

EXPORT_C void CCoeDataStorage::SetSystemColorListL(const CColorList& aColorList)

	{

	CBufFlat* const buffer=CBufFlat::NewL(KColorListBufferGranularity);

	CleanupStack::PushL(buffer);

	RBufWriteStream writeStream(*buffer);

	aColorList.ExternalizeL(writeStream);

	writeStream.CommitL();

	const TPtrC8 data(buffer->Ptr(0));

	SetSystemColorListFromBufferL(data);

	CleanupStack::PopAndDestroy(buffer);

	}

EXPORT_C void CCoeDataStorage::SetSystemColorListFromBufferL(const TDesC8& aBuffer)

	{

	User::LeaveIfError(SystemColorListRepositoryL().Set(KSystemColorRepositoryKey, aBuffer));

	}

/**

Returns a new color list object. The list will be populated from a configuration ini-file.

If the ini-file cannot be found, the list will be populated with the default colors from eikpriv.rsc.

*/

EXPORT_C CColorList* CCoeDataStorage::PopulateColorArrayL()

	{

	CColorList* colorList =GetSystemColorListL();

	if (colorList==NULL)

		{

		TInt numGrays=0;

		TInt numColors=0;

		RFs fs;

		CleanupClosePushL(fs);

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

		RWsSession ws;

		CleanupClosePushL(ws);

		User::LeaveIfError(ws.Connect(fs));

		TDisplayMode defaultMode=ws.GetDefModeMaxNumColors(numColors,numGrays);

		const TInt resourceId=(defaultMode>=EColor16? KCoeColorColor16:KCoeColorGray4);

		_LIT(KResourceFileName,"z:\\Resource\\Uiklaf\\eikpriv.rsc");

		TFileName resourceFileName(KResourceFileName);

		BaflUtils::NearestLanguageFile(fs,resourceFileName);

		if (!(BaflUtils::FileExists(fs, resourceFileName)))

			{

			_LIT(KAppResourceFileName,"z:\\Resource\\Apps\\eikpriv.rsc");

			resourceFileName = KAppResourceFileName;

			BaflUtils::NearestLanguageFile(fs,resourceFileName);

			}

		RResourceFile resourceFile;

		resourceFile.OpenL(fs, resourceFileName);

		CleanupClosePushL(resourceFile);

		resourceFile.ConfirmSignatureL(ECoeResourceSignatureValue);

		resourceFile.Offset();

		HBufC8* resource= resourceFile.AllocReadLC(resourceId);

		TResourceReader reader;

		reader.SetBuffer(resource);

		const TInt listId=reader.ReadInt32();

		const TInt extrasId=reader.ReadInt32();

		HBufC8* resourceList =resourceFile.AllocReadLC(listId);

		reader.SetBuffer(resourceList);			

		CColorArray* colorArray=CColorArray::NewLC();

		ResourceUtils::PopulateColorArrayL(*colorArray,reader);

		__ASSERT_ALWAYS(colorArray->Count()==EColorLabelHighlightFullEmphasis+1,Panic(ECoePanicInvalidColorRange));

		CArrayFix<TRgb>* colors=new(ELeave) CArrayFixFlat<TRgb>(8);

		CleanupStack::PushL(colors);

		for (TInt ii=EColorWindowBackground;ii<=EColorLabelHighlightFullEmphasis;ii++)

			{

			__ASSERT_ALWAYS(colorArray->Contains(ii),Panic(ECoePanicLogicalColorNotFound));

			colors->InsertL(STATIC_CAST(TLogicalColor,ii),colorArray->Color(ii));

			}

		colorList=CColorList::NewL(colors);

		CleanupStack::Pop(colors); // colors

		CleanupStack::PushL(colorList);

		CColorArray* extrasArray=CColorArray::NewLC();

		HBufC8* resourceExtras=resourceFile.AllocReadLC(extrasId);

		reader.SetBuffer(resourceExtras);		

		ResourceUtils::PopulateColorArrayL(*extrasArray,reader);

		colorList->AddColorArrayL(TUid::Uid(KCoeCustomColorsArrayValue),extrasArray);

		CleanupStack::PopAndDestroy(resourceExtras);

		CleanupStack::Pop(extrasArray); // extrasArray

		TRAP_IGNORE(SetSystemColorListL(*colorList) );

		CleanupStack::Pop(colorList);

		CleanupStack::PopAndDestroy(colorArray); // colorArray

		CleanupStack::PopAndDestroy(resourceList);

		CleanupStack::PopAndDestroy(resource);

		CleanupStack::PopAndDestroy(3); // resourceFile,ws, fs

		}

	return colorList;

	}

CRepository& CCoeDataStorage::FepFrameworkRepositoryL()

	{

	if (iFepFrameworkRepository==NULL)

		{

		iFepFrameworkRepository=CRepository::NewL(TUid::Uid(KUidFepFrameworkRepository));

		}

	return *iFepFrameworkRepository;

	}

CRepository& CCoeDataStorage::FepSpecificSettingsRepositoryL()

	{

	if (iFepSpecificSettingsRepository==NULL)

		{

		iFepSpecificSettingsRepository=CRepository::NewL(TUid::Uid(KUidFepSpecificSettingsRepository));

		}

	return *iFepSpecificSettingsRepository;

	}

CRepository& CCoeDataStorage::SystemColorListRepositoryL()

	{

	if (iSystemColorListRepository==NULL)

		{

		iSystemColorListRepository=CRepository::NewL(TUid::Uid(KUidSystemColorRepository));

		}

	return *iSystemColorListRepository;

	}

CBufFlat* CCoeDataStorage::GetSystemColorListBufferLC(TBool& aExists)

	{

	aExists=ETrue;

	CRepository& repository=SystemColorListRepositoryL();

	CBufFlat* const buffer=CBufFlat::NewL(2048);

	CleanupStack::PushL(buffer);

	FOREVER

		{

		TInt sizeOfBufferToAllocate=0;

		TPtr8 bufferAsDescriptor(buffer->Ptr(0));

		const TInt error=repository.Get(KSystemColorRepositoryKey, bufferAsDescriptor, sizeOfBufferToAllocate);

		if (error==KErrOverflow)

			{

			buffer->ResizeL(sizeOfBufferToAllocate);

			}

		else

			{

			if (error==KErrNotFound)

				{

				aExists=EFalse;

				}

			else

				{

				User::LeaveIfError(error);

				}

			break;

			}

		}

	return buffer;

	}

// CCoeDataStorage::COwner

CCoeDataStorage::COwner::COwner(CCoeDataStorage* aDataStorage)

	:CCoeStatic(TUid::Uid(ECoeStaticUid), KMinTInt), // the second parameter (aDestructionPriority) must be less than zero so that this CCoeStatic object still exists when the CCoeEnv's iExtra->iFepTracker is destroyed, as CCoeFepTracker's destructor uses this CCoeStatic object (via CCoeFepTracker's iRepository reference)

	 iDataStorage(aDataStorage)

	{

	}

CCoeDataStorage::COwner::~COwner()

	{

	delete iDataStorage;

	}