// 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 "srvdefs.h"

#include "srvres.h"

#include "shrepos.h"

#include "srvrepos_noc.h"

#include "obsrvr_noc.h"

#include "srvparams.h"

CSharedRepository* CSharedRepository::NewL(TUid aUid)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aUid);

	CleanupStack::Pop(self);

	// debug check that CRepository::TTransactionMode modes match those used internally

	// from CRepositoryTransactor: internal state logic relies on this

	// there should be a better location for these checks...

	ASSERT(CRepository::EReadTransaction == static_cast<CRepository::TTransactionMode>(EReadTransaction));

	ASSERT(CRepository::EConcurrentReadWriteTransaction == static_cast<CRepository::TTransactionMode>(EConcurrentReadWriteTransaction));

	ASSERT(CRepository::EReadWriteTransaction == static_cast<CRepository::TTransactionMode>(EReadWriteTransaction));

	return self;

	}

void CSharedRepository::ConstructL(TUid aUid)

	{

	iSimRep = CHeapRepository::NewL(aUid);

	}

CSharedRepository::CSharedRepository() : iNotificationState(ETrue)

	{

	}

CSharedRepository::~CSharedRepository()

	{

	if (iSimRep)

		{

		delete iSimRep;

		}

	}

TUid CSharedRepository::Uid() const

	{

	return iSimRep->Uid();

	}

/**

Stores the repository in-memory content to the related repository file on drive C.

If the operation fails, the in-memory content won't match the content of 

the repository file (which will be kept as it was before the CommitChangesL() call).

In order to keep the consistency, the in-memory repository content is deleted now

and restored later, on the next repository operation.

*/

TInt CSharedRepository::CommitChanges(TCentRepLocation aLocation)

	{

	iInconsistentData=ETrue;

	HBufC* filePath(NULL);	   

	TRAPD(err,TServerResources::CreateRepositoryFileNameL(filePath,iSimRep->Uid(),aLocation,ECre));	

	if (err!=KErrNone)

		{

		iSimRep->ResetContent();

		return err;		

		}

	// should not be committing while transactions are still active

	ASSERT(!IsTransactionActive());

	TInt ret=iSimRep->CommitChanges(TServerResources::iFs,TServerResources::iPersistsVersion,*filePath);

	if (ret==KErrNone)

		{

		iInconsistentData=EFalse;	

		}

	delete filePath;

	return ret;

	}

// merge transaction settings (which may include entries flagged as deleted), persist and notify

// private method relies on calling code to ensure it is permitted to make changes here.

// if this method is committing any changes, it cancels all other sessions' transactions

TInt CSharedRepository::DoCommitTransactionSettings(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo)

	{

	aKeyInfo = KUnspecifiedKey;

	if (0 == aTransactor.iTransactionSettings.Count())

		{

		aKeyInfo = 0; // == number of settings modified

		return KErrNone; // nothing to do

		}

	TInt error = iSimRep->SettingsArray().MergeArray(aTransactor.iTransactionSettings, iSimRep->DeletedSettingsArray(), ETransactionMerge);

	TInt numChanges = aTransactor.iTransactionSettings.Count();

	if (numChanges == 0)

		{

		if (error == KErrNone)

			{

			aKeyInfo = 0; // no changes

			}

		// no changes were made, so the internal cache is still valid.

		// This could be because there were no changes: empty list, only deletes on

		// non-existent items (a setting created and deleted in the transaction),

		// or because of error, such as failure of an initial realloc failure.

		return error;

		}

	if (error != KErrNone)

		{

		// the repository is corrupted. Dump it for lazy loading later

		ResetContent();

		// mark cache as inconsistent so it is reloaded.

		iInconsistentData = ETrue;	

		return error;	

		}

	if (error == KErrNone)

		{

		// changes have been made: fail all other sessions' transactions so we can commit

		FailAllTransactions(/*aExcludeTransactor=*/&aTransactor);

		error = CommitChanges(); // this already calls ResetContent() in case of failure

		}

	if (error == KErrNone)

		{

		// settings are now persistent on disk: we can now notify about the changes

		// following will notify about objects that are created and deleted in the transaction

		// this could be made faster by having a multiple Notify method.

		// That would also allow Notify messages to be more descriptive - ranges of Keys

		for (TInt i = 0; i < numChanges; i++)

			{

			Notify(aTransactor.iTransactionSettings[i].Key());

			}

		aKeyInfo = /*reinterpret_cast<TUint32>*/numChanges;

		}

	return error;

	}

void CSharedRepository::SetMetaDataOnRead(TServerSetting& aSetting, TBool aSingleMetaFound)

	{

	iSimRep->SetMetaDataOnRead(aSetting, aSingleMetaFound);

	}

void CSharedRepository::SetMetaDataOnCreate(TServerSetting& aNewSetting, TUint32* aMeta)

	{

	if(aMeta)

		{

		aNewSetting.SetMeta(*aMeta);

		}

	else

		{

		// No metadata specified. First check for a matching "range" default

		// metadata setting

		TSettingsDefaultMeta* defaultMeta = iSimRep->RangeMetaArray().Find(aNewSetting.Key());

		if (defaultMeta)

			{

			aNewSetting.SetMeta(defaultMeta->GetDefaultMetadata());

			}

		else

			{

			// Range value not found, try for a repository default

			aNewSetting.SetMeta(iSimRep->DefaultMeta());

			}

		}	

	}

void CSharedRepository::CreateL(TServerSetting& aSetting, TSettingsAccessPolicy*& aPolicy, TBool aFirstLoad, TBool aSingleMetaFound)

	{

	User::LeaveIfError(iSimRep->Create(aSetting, aPolicy, aSingleMetaFound));

	if (!aFirstLoad)

		{

		Notify(aSetting.Key());

		}

	}

// deletes an individual setting in the shared repository and makes it persistent

// if changes are made, all sessions' transactions are failed

TInt CSharedRepository::DeleteAndPersist(TUint32 aId)

	{

	TServerSetting* s = iSimRep->SettingsArray().Find(aId);

	if(!s)

		return KErrNotFound;

	iSimRep->SettingsArray().Remove(aId);

	// removed a setting, so must fail all sessions' transactions before commit possible

	FailAllTransactions(/*aExcludeTransactor=*/NULL);

	TInt error = CommitChanges();

	if (error == KErrNone)

		{

		Notify(aId);

		}

	return error;

	}

// deletes an individual setting without making it persistent

// must not be called while any sessions are in transactions

TInt CSharedRepository::DeleteNoPersist(TUint32 aId)

	{

	// should only be calling this if no transactions are active

	ASSERT(!IsTransactionActive());

	TServerSetting* s = iSimRep->SettingsArray().Find(aId);

	if(!s)

		return KErrNotFound;

	iSimRep->SettingsArray().Remove(aId);

	return KErrNone;	

	}

TInt CSharedRepository::ResetNoPersistL(TServerSetting& aSetting)

	{

	TServerSetting* s = iSimRep->SettingsArray().Find(aSetting.Key());

	if ((!s) || (*s != aSetting))

		{

		if (s)

			{

			// save access policy of setting

			TSettingsAccessPolicy* policy=s->AccessPolicy();

			s->Transfer(aSetting);

			// restore access policy of setting

			s->SetAccessPolicy(policy);

			}

		else

			{

			TServerSetting setting;

			setting.Transfer(aSetting);

			setting.SetAccessPolicy(GetFallbackAccessPolicy(setting.Key()));

			setting.PushL();

			iSimRep->SettingsArray().OrderedInsertL(setting);

			TInt index = iSimRep->DeletedSettingsArray().FindInUnsignedKeyOrder(aSetting.Key());

			if (index != KErrNotFound)

				iSimRep->DeletedSettingsArray().Remove(index);

			setting.Pop();

			}

		}

	else

		{

		return KErrGeneral;

		}

	return KErrNone;

	}

// if changes are made, all sessions' transactions are failed

void CSharedRepository::ResetAndPersistL(TServerSetting& aSetting)

	{

	if (ResetNoPersistL(aSetting) == KErrNone)

		{

		// changed a setting, so must fail all sessions' transactions

		// before commit possible

		FailAllTransactions(/*aExcludeTransactor=*/NULL);

		CommitChangesL();

		Notify(aSetting.Key());

		}

	}

TInt CSharedRepository::ResetAllNoPersistL(CSharedRepository& aNewContent)

	{

	// mark cache as inconsistent in case Reset fails, so it is reloaded.

	iInconsistentData=ETrue;

	// should not change repository while transactions in progress: should fail them first

	ASSERT(!IsTransactionActive());

	TInt newCount = (aNewContent.iSimRep)->SettingsArray().Count();

	TInt count = iSimRep->SettingsArray().Count();

	TInt newIndex = 0;

	TInt index = 0;

	while(newIndex<newCount && index<count)

		{

		const TServerSetting& newSetting = (aNewContent.iSimRep)->SettingsArray()[newIndex];

		const TServerSetting& setting = iSimRep->SettingsArray()[index];

		TUint32 newKey = newSetting.Key();

		TUint32 key = setting.Key();

		if(newKey<key)

			{

			Notify(newKey);

			newIndex++;

			}

		else if(newKey==key)

			{

			if(newSetting!=setting)

				{

				Notify(key);

				}

			newIndex++;

			index++;

			}

		else if(newKey>key)

			{

			Notify(key);

			index++;

			}

		}

	while(newIndex<newCount)

		{

		Notify((aNewContent.iSimRep)->SettingsArray()[newIndex++].Key());

		}

	while(index<count)

		{

		Notify(iSimRep->SettingsArray()[index++].Key());

		}

	// Replace current settings with settings read from ROM, this 

	// will leave settings pointing to new single policies

	iSimRep->SettingsArray().AdoptL((aNewContent.iSimRep)->SettingsArray());

	// Reset policy pointers to point at this repositories policies

	newCount=iSimRep->SettingsArray().Count();

	for(TInt i=0; i<newCount;i++)

		{

		(iSimRep->SettingsArray())[i].SetAccessPolicy(NULL);

		TUint32 key = (iSimRep->SettingsArray())[i].Key();

		(iSimRep->SettingsArray())[i].SetAccessPolicy(GetFallbackAccessPolicy(key));

		}	

	iSimRep->DeletedSettingsArray().Reset();

	iInconsistentData=EFalse;

	return KErrNone;

	}

// returns the read security policy used if there is no per-setting policy at aId

const TSecurityPolicy& CSharedRepository::GetFallbackReadAccessPolicy(TUint32 aId)

	{

	return iSimRep->GetFallbackReadAccessPolicy(aId);

	}

// returns the write security policy used if there is no per-setting policy at aId

const TSecurityPolicy& CSharedRepository::GetFallbackWriteAccessPolicy(TUint32 aId)

	{

	return iSimRep->GetFallbackWriteAccessPolicy(aId);

	}

// Get pointer to security policy that applies to a given setting

TSettingsAccessPolicy* CSharedRepository::GetFallbackAccessPolicy(TUint32 aId

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,TBool aSkipSingle

#endif	

	)

	{

	return iSimRep->GetFallbackAccessPolicy(aId

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,aSkipSingle

#endif	

	);

	}

TInt CSharedRepository::ReadSettingSavePolicyL(CIniFileIn& aFile,TServerSetting& aSetting, TSettingsAccessPolicy*& aPolicy, TBool& aSingleMetaFound)

	{

	return iSimRep->ReadSettingSavePolicyL(aFile, aSetting, aPolicy, aSingleMetaFound);

	}	

// Merge settings in this->iSettings with the iSettings of aMergeRep

// During an intsall/upgrade event aMergeRep will be created from the installed file

// During an upinstall event aMergeRep will be created from the ROM file

void CSharedRepository::MergeL(CSharedRepository& aMergeRep, TMergeType aMergeType)

	{

	// Process settings from main section - this updates values only

	User::LeaveIfError(GetSettings().MergeArray(aMergeRep.GetSettings(), iSimRep->DeletedSettingsArray(), aMergeType));

	//if the merging is due to a ROM Flash, we need to copy over both the NEW ROM keypsace global properties

	//(default access policies/metadata and range policies/metadata), individual policies, we then need to ensure

	//that the settings point at the correct individual policies and metadata.

	if (aMergeType==ERomFlash)

		{

		//copy the default/range/individual policy

		iSimRep->SetDefaultPolicy(aMergeRep.iSimRep->GetDefaultAccessPolicy());

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

		iSimRep->GetDefaultAccessPolicy().iHighKey=aMergeRep.iSimRep->GetDefaultAccessPolicy().iHighKey;

		iSimRep->GetDefaultAccessPolicy().iKeyMask=aMergeRep.iSimRep->GetDefaultAccessPolicy().iKeyMask;		

#endif		

		iSimRep->RangePolicyArray().Reset();

		TInt count=aMergeRep.iSimRep->RangePolicyArray().Count();

		iSimRep->RangePolicyArray().ReserveL(count);

		for (TInt i=0;i<count;i++)

			{

			iSimRep->RangePolicyArray().AppendL(aMergeRep.iSimRep->RangePolicyArray()[i]);

			}

		iSimRep->SinglePolicyArray().ResetAndDestroy();

		count=aMergeRep.iSimRep->SinglePolicyArray().Count();

		iSimRep->SinglePolicyArray().ReserveL(count);

		for (TInt i=0;i<count;i++)

			{

			iSimRep->SinglePolicyArray().AppendL(aMergeRep.iSimRep->SinglePolicyArray()[i]);

			}

		//now need to reset the aMergeRep single policies so it is not going to destroy the

		//individual policies as ownership has been transferred

		aMergeRep.iSimRep->SinglePolicyArray().Reset();

		//copy the default/range metadata

		iSimRep->SetDefaultMeta(aMergeRep.iSimRep->DefaultMeta());

		iSimRep->RangeMetaArray().Reset();

		count=aMergeRep.iSimRep->RangeMetaArray().Count();

		iSimRep->RangeMetaArray().ReserveL(count);		

		for (TInt i=0;i<count;i++)

			{

			iSimRep->RangeMetaArray().AppendL(aMergeRep.iSimRep->RangeMetaArray()[i]);

			}

		//set the timestamp,owner etc

		iSimRep->SetTimeStamp(aMergeRep.iSimRep->TimeStamp());

		iSimRep->SetOwner(aMergeRep.iSimRep->Owner());

		}

	// Update all access policies and meta

	for(TInt i=0; i<iSimRep->SettingsArray().Count();i++)

		{

		TServerSetting& setting= iSimRep->SettingsArray()[i];

		setting.SetAccessPolicy(GetFallbackAccessPolicy(setting.Key()));

		}	

	}

// Save timestamp of installed file 

void CSharedRepository::SetInstallTime(TTime aInstallTime)

	{

	iSimRep->SetTimeStamp(aInstallTime);

	}

// Handle creation or upgrade of file in install directory

void CSharedRepository::HandleUpdateMergeL(TTime aInstallFileTimeStamp, CSharedRepository& aInstallRep)

	{			

	MergeL(aInstallRep, ESWIUpgradeMerge);

	SetInstallTime(aInstallFileTimeStamp);	// Set merge timestamp		

	CommitChangesL();						// Commit changes to write system drive file

	// settings are now persistent on disk: we can now notify about the changes

	for (TInt i = 0; i < (aInstallRep.iSimRep)->SettingsArray().Count(); i++)

		{

		Notify((aInstallRep.iSimRep)->SettingsArray()[i].Key());

		}

	}

// Handle merge activity due to an uninstall

void CSharedRepository::HandleDeleteMergeL(CSharedRepository& aRomRep)

	{

	MergeL(aRomRep, ESWIDowngradeMerge);

	SetInstallTime(0);						// Reset timestamp			

	CommitChangesL();						// Commit changes to write system drive file

	// settings are now persistent on disk: we can now notify about the changes

	for (TInt i = 0; i < (aRomRep.iSimRep)->SettingsArray().Count(); i++)

		{

		Notify((aRomRep.iSimRep)->SettingsArray()[i].Key());

		}

	}

#ifdef CENTREP_CONV_TOOL

/**

Statement "iInconsistentData = ETrue;" must be the first statement in the method,

"iInconsistentData = EFalse;" must be the last. It is used for lasy-load implementation

for the repository and solves the problem that if CommitChangesL() fails the in-memory

repository data won't match the repository data, stored in the file.

This routine is being retained for testing purposes

*/

void CSharedRepository::DoCommitChangesToIniFileL(const TDesC& aOutFileName

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,TUint32 aCreVersion

#endif

	)

	{

	iInconsistentData=ETrue;

	// should not be committing while transactions are still active

	ASSERT(!IsTransactionActive());

	iSimRep->DoCommitChangesToIniFileL(TServerResources::iFs,aOutFileName

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS