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

 #define OBSRVR_H

 #include <e32base.h>

 class CSharedRepository;

 class CServerRepository;

 class CRepositoryTransactor;

 #include "inifile.h"

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

 class CHeapRepository;

 /**

 This simple T class is used to store information regarding

 the keyspace entry in the rofs list with respect to the

 extension used and the mount id order

 */

 class TRofsFlag

 {

 public:

 	TRofsFlag(const TDesC& aExt,TUint8 aMountId):iFlag(aMountId)

 		{

 		if (aExt.Compare(_L("txt"))==0)

 			{

 			iFlag |=0x80000000;

 			}

 		}

 	static TInt CompareFlag(const TRofsFlag& aFlag1, const TRofsFlag& aFlag2)

 		{

 		return (aFlag1.iFlag & 0xFF)-(aFlag2.iFlag & 0xFF);

 		}

 public:

 	//the 16 bit flag in format of |8bit cre/txt flag|8bit mount_id|

 	//obviously this is assuming the format of the mangled file

 	//granulatiry currently set to default of 8 which is reasonable

 	//MSB=1 indicates this is txt

 	TUint32 iFlag;	

 };

 /**

 This class is used to store information about potentially multiple

 files(in diffeernt rofs) used for a centrep keyspace

 */

 class TMultiRofsList

 	{

 public:

 	TMultiRofsList(TUid aUid):iRepUid(aUid){}

 public:

 	//repository uid

 	TUid iRepUid;

 	//list of the mount ids together with the extension(cre/txt)

 	RArray<TRofsFlag> iMountFlagList;		

 	};

 #endif	

 class MObserver

 	{

 public:

 	virtual void Notify(TUint32 aId) = 0;

 	};

 class CObservable : public CBase

 	{

 public:

 	static CObservable* NewLC();

 	~CObservable();

 	void AddObserverL(TUid aUid, CServerRepository* aRepositoryPointer);

 	void RemoveObserver(TUid aUid, CServerRepository* aRepositoryPointer, TInt aInMemoryIndex);

 	void Notify(TUid aUid, TUint32 aVal) const;

 	void ReleaseTransactionLock(CRepositoryTransactor& aTransactor,TUid aRepositoryUid);

 	void CancelTransaction(CRepositoryTransactor& aTransactor,TUid aRepositoryUid);	

 	TInt FindOpenRepository(TUid aUid) const;

 	void RemoveOpenRepository(CSharedRepository* aRepository);

 	inline CSharedRepository*& GetOpenRepository(TInt aIndex) 

 		{

 		ASSERT((aIndex>=0)&&(aIndex<iOpenRepositories.Count()));

 		return iOpenRepositories[aIndex];

 		}

 	inline void AddOpenRepositoryL(CSharedRepository* aRepository)

 		{

 		iOpenRepositories.AppendL(aRepository);

 		}

 	TInt FindConnectedRepository(TUid aUid) const;

 #ifdef CACHE_OOM_TESTABILITY

 	void CloseiOpenRepositories();

 	void CloseiRepositoryInfo();

 	void Reset();

 	TBool iTrapOOMOnOpen;

 #endif	

 	CSharedRepository* AccessL(TUid aUid, TBool aFailIfNotFound = ETrue);

 	void LoadRepositoryLC(TUid aUid, TBool aFailIfNotFound, CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode);

 	/**

 	@internalTechnology

 	This is the class/structure which keeps shared non-persisted repository data 

 	*/

 	class TSharedRepositoryInfo

 		{

 	public:

 		TSharedRepositoryInfo(TUid aUid);

 		TUid iRepositoryUid;

 		// all transactors in the order added

 		TSglQue<CRepositoryTransactor> iTransactors;

 		// combined read/write lock for pessimistic transactions.

 		// -1 if in EReadWriteTransaction, otherwise non-negative number of EReadTransactions.

 		TInt iPessimisticTransactionLockCount;

 		// count of active concurrent read/write transactions:

 		TInt iNumActiveConcurrentReadWriteTransactions;

 		};

 	TSharedRepositoryInfo* SharedRepositoryInfo(TUid aUid);		

 	void AddSharedRepositoryInfoL(TUid aUid);

 	void RemoveSharedRepositoryInfo(TUid aUid);

 	TInt CreateRepositoryL(CSharedRepository* aRepository, TCentRepLocation aLocation);

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	void ProcessMultiRofsListL(const CDir& aList);	

 	static TInt CompareUid(const TMultiRofsList& aUid1, const TMultiRofsList& aUid2);		

 	RArray<TMultiRofsList>& GetMultiRofsList()

 		{

 		return iMultiRofsUidList;	

 		}

 #endif		

 	/**

 	@internalTechnology

 	This is the class/structure which keeps notification-related data 

 	*/

 	class TRepositoryObserverInfo

 		{

 	public:

 		TUid iRepositoryUid;

 		CServerRepository* iRepositoryPointer; 

 		};

 	RArray<TRepositoryObserverInfo> iObservers;		

 private:

 	static TInt ObserverSortOrder(const TRepositoryObserverInfo &aRepository1, const TRepositoryObserverInfo &aRepository2);

 	static TInt InfoSortOrder(const TSharedRepositoryInfo &aRepository1, const TSharedRepositoryInfo &aRepository2);

 	static TInt CompareTUidValues(TInt aUid1, TInt aUid2);

 	TInt ReadIniFileL(CSharedRepository*& aRepository,TCentRepLocation aLocation);

 	TInt CreateRepositoryL(CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode);

 	TInt ReadSettingsL(CIniFileIn* aIniFileIn, CSharedRepository* aRep);

 	TInt FindRepositoryInfo(TUid aUid);

 	void RefreshTransactorAccessPolicies(CSharedRepository* aRepository, const TInt offset);

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	//Multi ROFS stuff

 	void ConstructL();

 	void OverrideSettingL(TServerSetting& aBaseSetting,const TServerSetting& aOvSetting,CSharedRepository* aCoreRepository,TBool aNewOv,TBool aNewOvIndivPolicy);	

 	void MergeRepositoryL(CSharedRepository* aCoreRepository,CHeapRepository* aOverrideRepository);

 	void MergeMultiRofsL(TBool aCoreInitialized,CSharedRepository* aCoreRepository,const RArray<TRofsFlag>& aOverridingFileList);

 #endif

 private:

 	enum {KGranularity=8};	

 	RPointerArray<CSharedRepository> iOpenRepositories;	

 	RPointerArray<TSharedRepositoryInfo> iRepositoryInfo;

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	RArray<TMultiRofsList> iMultiRofsUidList;

 #endif		

 	};

 #endif // OBSRVR_H