// 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:

//

#ifndef SHREPOS_H

#define SHREPOS_H

#include <e32base.h>

#include "obsrvr_noc.h"

#include "srvres.h"

#include "srvdefs.h"

#include "setting.h"

#include "clientrequest.h"

#include "panic.h"

#include "transstate.h"

#include "inifile.h"

#include "rstrepos.h"

#include "datatype.h"

#include "heaprepos.h"

class CRepositoryTransactor;

class CSharedRepository : public CBase

	{

	friend class CObservable;

	friend class CServerRepository;

	friend class TConvToolTester;

public:

	static CSharedRepository* NewL(TUid aUid);

	~CSharedRepository();

	TUid Uid() const;

	TInt CommitChanges(TCentRepLocation aLocation = EPersists);

	void CommitChangesL(TCentRepLocation aLocation = EPersists)

		{

		User::LeaveIfError(CommitChanges(aLocation));

		}

	void CreateL(TServerSetting& s, TSettingsAccessPolicy* &aPolicy, TBool aFirstLoad, TBool aSingleMetaFound=EFalse);

	void SetMetaDataOnRead(TServerSetting& aSetting, TBool aSingleMetaFound);

	void SetMetaDataOnCreate(TServerSetting& aNewSetting, TUint32* aMeta);

	TInt DeleteAndPersist(TUint32 aId);

	TInt DeleteNoPersist(TUint32 aId);

	TInt ResetNoPersistL(TServerSetting& aSetting);

	void ResetAndPersistL(TServerSetting& aSetting);

	TInt ResetAllNoPersistL(CSharedRepository& aRepository);

	const TSecurityPolicy& GetFallbackReadAccessPolicy(TUint32 aId);

	inline const TSecurityPolicy& GetReadAccessPolicy(const TServerSetting& aSetting);

	inline const TSecurityPolicy& GetReadAccessPolicy(TUint32 aId);

	inline const TSecurityPolicy& GetDefaultReadAccessPolicy();

	const TSecurityPolicy& GetFallbackWriteAccessPolicy(TUint32 aId);

	inline const TSecurityPolicy& GetWriteAccessPolicy(const TServerSetting& aSetting);

	inline const TSecurityPolicy& GetWriteAccessPolicy(TUint32 aId);

	inline const TSecurityPolicy& GetDefaultWriteAccessPolicy();

	TSettingsAccessPolicy* GetFallbackAccessPolicy(TUint32 aId

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,TBool aSkipSingle=EFalse

#endif	

	);

	TInt StartTransaction(CRepositoryTransactor& aTransactor, TInt aMode);

	TInt CommitTransaction(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo);

	TInt FailTransaction(CRepositoryTransactor& aTransactor, TInt aError, TUint32 aErrorKey);

	void FailAllTransactions(const CRepositoryTransactor* aExcludeTransactor);

	TInt AttemptPromoteTransactionToReadWrite(CRepositoryTransactor& aTransactor);

	TBool IsTransactionActive();

	void	MergeL(CSharedRepository& aInstallRep, TMergeType aMergeType);

#ifndef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

	TInt FindLocationForFileL(TCentRepLocation& aLocation,TUid aUid,const TCentRepFileType aType) const;

#endif	

	void	HandleUpdateMergeL(TTime aInstallFileTimeStamp, CSharedRepository& aInstallRep);

	void	HandleDeleteMergeL(CSharedRepository& aRomRep);

	void	SetInstallTime(TTime aInstallTime);

	inline TUid Owner() {return iSimRep->Owner(); }

	inline void WriteBackupStream(RWriteStream& aStream) const;

	inline void WriteDeletedSettingsStream(RWriteStream& aStream) const;

	inline void InternalizeL(RReadStream& aStream, CRestoredRepository& aRstRepos) ;

	void ExternalizeCre(RWriteStream& aStream) const;

	void InternalizeCreL(RReadStream& aStream) ;

#ifdef	SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	void InternalizeCreL(RReadStream& aStream,TUint8& aCreVersion);

#endif		

	TInt ReloadContentL(CIniFileIn& aIniFile, TBool aFirstLoad = EFalse);

#ifdef CENTREP_CONV_TOOL	

	void DoCommitChangesToIniFileL(const TDesC& aOutFileName

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,TUint32 aCreVersion

#endif	

	);

#endif	

	inline void SetSize(TInt aSize);

	inline TInt Size() const;

private:

	void	ResetContent();

	void	RestoreConsistencyL();

	void 	DoRestoreConsistencyL();

	TInt	CreateRepositoryFromCreFileL(TCentRepLocation aLocation);

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

	TInt DoCommitTransactionSettings(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo);

	void Notify(TUint32 aVal) const;

	RSettingsArray& GetSettings();

	CSharedRepository();	

	void ConstructL(TUid aUid);

#ifdef FOTA_UNIT_TESTING	

public:

	void SetUid(TUid aUid)

		{

		iSimRep->SetUid(aUid);

		}

#endif

	CHeapRepository* iSimRep;

	TInt32 iSize; //approximate size(in memory) of the repository after internalisation

	TBool iNotificationState;//Notification can be made if iNotificationState is non-zero, 

	                         //otherwise the notification is disabled

	//iInconsistentData data flag will be set at the beginning of CommitChangesL()

	//and reset at the end of it. The flag is used to implement lazy-load approach for the

	//repository - if CommitChangesL() fails, the in-memory representation of the repository 

	//won't match the updated by CommitChangesL() repository (ini) file. The repository

	//consistency has to be restored before any next call of CSharedRepository methods.

	TBool iInconsistentData;	                         

	};

/**

@internalTechnology

Base class for CServerRepository and other objects that may be in transactions with the

shared repository. Contains a double queue link so the shared repository can build a queue

of them. In order to use transactions in the shared repository, the object needs to supply a

CRepositoryTransactor - either itself or a member variable. This makes it possible to

prevent one transactor from closing another's transaction.

Stores transaction state and changes made during the transaction.

Also stores RMessage2 while pending async start or commit, and handles its completion.

*/

class CRepositoryTransactor : public CBase

	{

	// shared repository may set private transaction state, but not derived classes

	friend class CSharedRepository;

	// for the _FOFF macro to work

	friend class CObservable::TSharedRepositoryInfo;

	friend class CObservable;

public:

	inline TInt TransactionState() const

		{

		return iTransactionState;

		}

	inline TInt TransactionMode() const

		{

		return iTransactionState & EAllTransactionModeBits;

		}

	inline TBool IsInTransaction() const

		{

		return iTransactionState != ENoTransaction;

		}

	inline TBool IsInActiveTransaction() const

		{

		// transaction is active if no bits apart from the (non-zero) mode are set

		return (iTransactionState != ENoTransaction) && (TransactionMode() == iTransactionState);

		}

	inline TBool IsInActiveReadTransaction() const

		{

		return iTransactionState == EReadTransaction;

		}

	inline TBool IsInActiveConcurrentReadWriteTransaction() const

		{

		return (iTransactionState == EConcurrentReadWriteTransaction);

		}

	inline TBool IsInActiveExclusiveReadWriteTransaction() const

		{

		return (iTransactionState == EReadWriteTransaction);

		}

	inline TBool IsInActiveReadWriteTransaction() const

		{

		return (iTransactionState == EReadWriteTransaction)

			|| (iTransactionState == EConcurrentReadWriteTransaction);

		}

	inline TBool IsInFailedTransaction() const

		{

		return (iTransactionState & EFailedBit) != 0;

		}

protected:

	inline void ClearSettings()

		{

		iTransactionSettings.Reset();

		}

private:

	inline void SetFailed(TInt aError, TUint32 aErrorKey)

		{

		// don't want to fail more than once

		ASSERT(IsInActiveTransaction());

		ASSERT(aError != KErrNone); // must fail for a reason

		iTransactionState |= EFailedBit;

		ClearSettings();

		iTransactionResult = aError;

		iTransactionErrorKey = aErrorKey;

		}

	inline void PromoteToExclusiveReadWrite()

		{

		ASSERT(iTransactionState == EReadTransaction);

		iTransactionState = EReadWriteTransaction;

		ClearSettings();

		}

	inline void AddToQueue(TSglQue<CRepositoryTransactor>& aTransactors, TInt aMode)

		{

		ASSERT(!IsInTransaction());

		// if the following ASSERT fails, transactor is already in a queue

		ASSERT(iLink.iNext == NULL);

		aTransactors.AddLast(*this);

		iTransactionState = aMode;

		// check adding to queue in an active state

		ASSERT(IsInActiveTransaction());

		ClearSettings();

		// clear failure reasons

		iTransactionResult = KErrNone;

		iTransactionErrorKey = KUnspecifiedKey;

		}

	inline void Deque()

		{

		iTransactionState = ENoTransaction;

		ClearSettings();

		delete iIniRep;

		iIniRep = NULL;

		}

protected:

	// derived classes are free to change transaction settings.

	// these can be made persistent by committing write transaction

	RSettingsArray iTransactionSettings;

	// 'Create' needs to check the default (INI) file to see if the

	// key position has a setting defined. If that is the case,

	// the new setting uses meta defined for the original setting

	// in the INI file.

	// Store data read from INI here so that we only read the INI

	// once per transaction.

	CSharedRepository* iIniRep;

private:

	// A queue link used by the CSharedRepository the CTransactor is working on

	TSglQueLink iLink;

	// integer encoding transaction state using definition of TTransactionState

	TInt iTransactionState;

	// result to be returned by commit if transaction failed earlier

	TInt iTransactionResult;

	// if transaction failed earlier, key or partial key involved in the original error,

	// or KUnspecifiedKey if could not be attributed to just one.

	TUint32 iTransactionErrorKey;

	};

#include "shrepos.inl"

#endif // SHREPOS_H