// Copyright (c) 2004-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 "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

	,aCreVersion

#endif	

	);

	iInconsistentData = EFalse;

	}

#endif //CENTREP_CONV_TOOL

/**

The method reloads the repository content from a repository file.

The current repository must be emptied (or must be empty already) before the call is made.

@param aIniFile A reference to CIniFileIn object, which will be used to load

				the repository content.

@param aFirstLoad is used to indicate whether the file is reloaded for first time, this is used to prevent

notification if not needed. For example file loading for merging purpose will not result in notification

@return KErrCorrupt Corrupted repository file.

		KErrNone	The repository content was seccessfully loaded into memory.

		KErrNotFound Setting not found in the file.

@leave System-wide error codes.

@leave KErrGeneral It's probably a programmer's error - current CSharedRepository 

				   object is partially initialised.

*/

TInt CSharedRepository::ReloadContentL(CIniFileIn& aIniFile, TBool aFirstLoad)

	{

	// Preconditions - CHeapRepository object should be an empty one.

	if(!iSimRep->IsEmpty())

		{

		User::Leave(KErrGeneral);

		}

	TInt err = iSimRep->ReloadContentExceptSettingsL(aIniFile);

	if(err == KErrCorrupt)

		{

		return err;

		}

	CleanupClosePushL(iSimRep->RangeMetaArray());

	CleanupClosePushL(iSimRep->RangePolicyArray());

	// Settings

	TServerSetting setting;

	TSettingsAccessPolicy* policy;

	TBool singleMetaFound;

	TCleanupItem tc(CHeapRepository::SinglePoliciesCleanup, &(iSimRep->SinglePolicyArray()));

	CleanupStack::PushL(tc);