diff -r 000000000000 -r d0791faffa3f mtpfws/mtpfw/inc/cmtpobjectstore.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtpfws/mtpfw/inc/cmtpobjectstore.h	Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,349 @@
+// Copyright (c) 2006-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:
+//
+
+/**
+ @file
+ @internalComponent
+ */
+
+#ifndef CMTPOBJECTSTORE_H
+#define CMTPOBJECTSTORE_H
+
+#include <badesca.h>
+#include <d32dbms.h>
+
+#include "mtpframeworkconst.h"
+#include "rmtpframework.h"
+#include "mtpdebug.h"
+
+class CFileStore;
+class CMTPHandleAllocator;
+class CMTPObjectMetaData;
+class CMTPPuidMgr;
+class CMTPReferenceMgr;
+class CMTPTypeArray;
+class RMTPObjectMgrQueryContext;
+class TMTPTypeUint32;
+class TMTPTypeUint128;
+class TMTPObjectMgrQueryParams;
+class CMtpDeltaDataMgr;
+class CMTPDPIDStore;
+class CMTPPkgIDStore;
+/** 
+ Implements the MTP object meta data store, which manages the storage/mapping of object handle and suid, and puid using DMBS.
+ Note, the CMTPObjectMgr acts as a shim class which forwards all the requests to the CMTPObjectStore. 
+ The reason is that later on, the class CMTPObjectStore will also implement the reference manager and puid manager
+ functionalities.  Having a single class implements all these will enable us to use a single database with multiple 
+ tables.
+
+ @internalComponent
+ 
+ */
+class CMTPObjectStore : public CBase
+	{
+	class CDbCompactor : public CBase
+		{
+	public:
+		inline static CDbCompactor* NewL(RDbNamedDatabase* aDatabase)
+			{
+			CDbCompactor* self = new (ELeave) CDbCompactor(aDatabase);
+			return self;
+			}
+		inline void Compact()
+			{
+			if (!((++iCompactCnt) % KCompactCnt))
+				{
+				RDbDatabase::TSize size = iDatabase->Size();
+				iDatabase->Compact();
+				}
+			}
+		inline ~CDbCompactor()
+			{
+			}
+	private:
+		inline CDbCompactor(RDbNamedDatabase* aDatabase) : iDatabase(aDatabase)
+			{
+			}
+
+	private:
+		RDbNamedDatabase* iDatabase;
+		TUint8 iCompactCnt;
+		static const TUint8 KCompactCnt = 32; //Use this value make the performance better haven't test other value
+		};
+
+	class MTraverseAction
+		{
+	public:
+		typedef enum {EOnlyLoadedDP, EAllDP} TActionTarget;
+		MTraverseAction(TActionTarget aTarget) : iActionTarget(aTarget)
+			{
+			}
+		TActionTarget Target()
+			{
+			return iActionTarget;
+			}
+		virtual void DoL(RDbTable& aTable) = 0;
+		
+	private:
+		TActionTarget iActionTarget;
+		};
+	class TCountAction : public MTraverseAction
+		{
+	public:
+		TCountAction(TUint& aCounter, TActionTarget aTarget = EOnlyLoadedDP) : MTraverseAction(aTarget), iCounter(aCounter)
+			{
+			}
+		void DoL(RDbTable& /*aTable*/)
+			{
+			++iCounter;
+			}
+	private:
+		TUint& iCounter;
+		};
+
+	class TGetHandlesAction : public MTraverseAction
+		{
+	public:
+		TGetHandlesAction(RArray<TUint>& aHandles, TActionTarget aTarget = EOnlyLoadedDP) : MTraverseAction(aTarget), iHandles(aHandles)
+			{
+			}
+		void DoL(RDbTable& aTable)
+			{
+			iHandles.AppendL(aTable.ColUint32(EObjectStoreHandleId));
+			}
+	private:
+		RArray<TUint>& iHandles;
+		};
+
+	class TGetSuidsAction : public MTraverseAction
+		{
+	public:
+		TGetSuidsAction(CDesCArray& aSuids, TActionTarget aTarget = EOnlyLoadedDP) : MTraverseAction(aTarget), iSuids(aSuids)
+			{
+			}
+		void DoL(RDbTable& aTable)
+			{
+			TFileName buf;
+			RDbColReadStream suid;
+			suid.OpenLC(aTable, EObjectStoreSUID);
+			suid.ReadL(buf, aTable.ColLength(EObjectStoreSUID));
+			suid.Close();
+			CleanupStack::PopAndDestroy();
+			iSuids.AppendL(buf);
+			}
+	private:
+		CDesCArray& iSuids;
+		};
+	
+	class TDelAction : public MTraverseAction
+		{
+	public:
+		TDelAction(CMTPObjectStore& aStore, TActionTarget aTarget = EOnlyLoadedDP) : MTraverseAction(aTarget), iStore(aStore)
+			{
+			}
+		void DoL(RDbTable& aTable)
+			{
+			aTable.DeleteL();
+			iStore.IncTranOpsNumL();
+			}
+	private:
+		CMTPObjectStore& iStore;
+		};
+	
+public:
+
+	static CMTPObjectStore* NewL();
+	~CMTPObjectStore();
+
+public:
+
+	RDbDatabase& Database();
+	CMTPDPIDStore& DPIDStore() const;
+	CMTPPkgIDStore& PkgIDStore() const;
+	CMTPReferenceMgr& ReferenceMgr() const;
+	CMtpDeltaDataMgr* MtpDeltaDataMgr() const;
+	void RestorePersistentObjectsL(TUint aDataProviderId);
+	void RemoveObjectsByStorageIdL(TUint32 aStorageId);
+	void RemoveNonPersistentObjectsL(TUint aDataProviderId);
+	void MarkNonPersistentObjectsL(TUint aDataProviderId, TUint32 aStorageId);
+	void EstablishDBSnapshotL(TUint32 aStorageId);
+	void CleanDBSnapshotL();
+	void MarkDPLoadedL(TUint aDataProviderId, TBool aFlag);
+
+public:
+
+	TUint CountL(const TMTPObjectMgrQueryParams& aParams) const;
+	void GetObjectHandlesL(const TMTPObjectMgrQueryParams& aParams, RMTPObjectMgrQueryContext& aContext, RArray<TUint>& aHandles) const;
+	void GetObjectSuidsL(const TMTPObjectMgrQueryParams& aParams, RMTPObjectMgrQueryContext& aContext, CDesCArray& aSuids) const;
+	void TraverseL(const TMTPObjectMgrQueryParams& aParams, MTraverseAction& action) const;
+	void CalcFreeHandlesL(TUint aDataProviderId);
+	void CommitReservedObjectHandleL(CMTPObjectMetaData& aObject);
+	TUint32 HandleL(const TDesC& aSuid) const;
+	TUint32 HandleL(TUint32 aSuidHash, const TDesC& aSuid) const;
+	void InsertObjectL(CMTPObjectMetaData& aObject);
+	void InsertObjectsL(RPointerArray<CMTPObjectMetaData>& aObjects);
+	void ModifyObjectL(const CMTPObjectMetaData& aObject);
+	TBool ObjectL(const TMTPTypeUint32& aHandle, CMTPObjectMetaData& aObject) const;
+	TBool ObjectL(const TDesC& aSuid, CMTPObjectMetaData& aObject) const;
+	TBool ObjectExistsL(const TUint32 aHandle);
+	TMTPTypeUint128 PuidL(const TUint32 aHandle);
+	TMTPTypeUint128 PuidL(const TDesC& aSuid);
+
+	const TPtrC ObjectSuidL(TUint32 aHandle) const;
+	void RemoveObjectL(const TMTPTypeUint32& aHandle);
+	void RemoveObjectL(const TDesC& aSuid);
+	void RemoveObjectsL(const CDesCArray& aSuids);
+	void RemoveObjectsL(TUint aDataProviderId);
+	void ReserveObjectHandleL(CMTPObjectMetaData& aObject, TUint64 aSpaceRequired);
+	void UnreserveObjectHandleL(const CMTPObjectMetaData& aObject);
+	void IncTranOpsNumL();
+	TBool IsMediaFormat(TUint32 aFormatCode);
+
+	void BeginTransactionL();
+	void CommitTransactionL();
+
+	void CleanL();
+	TUint ObjectOwnerId(const TMTPTypeUint32& aHandle) const;
+private:
+
+	/**
+	 Enumeration representing the column fields in the object store DBMS, this definition must exactly match the sequence
+	 defined in KSQLCreateHandleTableText
+	 //During insert a object, only the following items is provided in the CMTPObjectMetaData
+	 //DPId
+	 //Format
+	 //FormatSubcode
+	 //StorageID
+	 //Modes
+	 //ParentHandle
+	 //
+	 //Handle is allocated by MTP framework
+	 //NonConsumable is inserted only by FileDP, for objects manged by LicenseeDP, its values is meaningless
+	 */
+	enum TObjectStore
+		{
+		EObjectStoreHandleId = 1,
+		EObjectStoreSUIDHash = 2,
+		EObjectStoreSUID = 3,
+		EObjectStoreDataProviderId = 4,
+		EObjectStoreFormatCode = 5,
+		EObjectStoreFormatSubCode = 6,
+		EObjectStoreStorageId = 7,
+		EObjectStoreModes = 8,
+		EObjectStorePOUID = 9,
+		EObjectStoreParentHandle = 10,
+		EObjectStoreDPFlag = 11,
+		EObjectStoreNonConsumable = 12,
+		EObjectStoreName = 13
+		};
+
+	class CEnumertingCacheItem : public CBase
+		{
+	public:
+		static CEnumertingCacheItem* NewLC(TUint32 aSuidHash, TUint32 aHandle, TUint32 aFormat, TUint64 aId, TUint8 aDpID)
+			{
+			CEnumertingCacheItem* self = new (ELeave) CEnumertingCacheItem(aSuidHash, aHandle, aFormat, aId, aDpID);
+			CleanupStack::PushL(self);
+			return self;
+			}
+		static CEnumertingCacheItem* NewL(TUint32 aSuidHash, TUint32 aHandle, TUint32 aFormat, TUint64 aId, TUint8 aDpID)
+			{
+			CEnumertingCacheItem* self = CEnumertingCacheItem::NewLC(aSuidHash, aHandle, aFormat, aId, aDpID);
+			CleanupStack::Pop();
+			return self;
+			}
+		static TInt Compare(const CEnumertingCacheItem& aFirst, const CEnumertingCacheItem& aSecond);
+		CEnumertingCacheItem(TUint32 aSuidHash, TUint32 aHandle, TUint32 aFormat, TUint64 aId, TUint8 aDpID);
+		~CEnumertingCacheItem()
+			{
+			delete iSuid;
+			}
+		TUint32 iObjHandleId;
+		TUint32 iObjSuiIdHash;
+		TUint32 iFormatcode;
+		TUint64 iPOUID;
+		HBufC* iSuid;
+		TPtrC iSuidPtr;
+		TUint8 iDpID;
+		};
+
+	CMTPObjectStore();
+	void ConstructL();
+
+private:
+
+	TBool LocateByHandleL(const TUint aHandle, const TBool aReadTable = ETrue) const;
+	TBool LocateBySuidL(const TDesC& aSuid) const;
+
+	void BuildObjectMetaDataL(CMTPObjectMetaData& aBuf, const RDbTable& aTable) const;
+	void InitializeDbL();
+	void CreateDbL(const TDesC& aFileName);
+	TInt OpenDb(const TDesC& aFileName);
+	void CloseDb();
+
+	void CreateHandleTableL();
+	void CreateHandleIndexL();
+	void CreateStorageTableL();
+	void CreateStorageIndexL();
+
+	void GetFullPathName(const TDesC& aName, TFileName& aFileName) const;
+
+	TBool GetObjectL(TUint32 aHandle, CMTPObjectMetaData& aObject) const;
+
+	static void DBUpdateFailRecover(TAny* aTable);
+    TBool IsInvalidHandle( TUint32 aHandle ) const;
+    TBool FilterObject(const RDbTable& aCurrRow,const TUint32 aStorageID,const TUint32 aFormatCode,const TUint32 aDpID) const;
+    void DbColWriteStreamL(RDbTable& aTable, TDbColNo aCol, const TDesC16& aDes);
+    void DbColReadStreamL(const RDbTable& aTable, TDbColNo aCol, TDes16& aDes) const;    
+
+private:
+
+	static const TUint KQueryWindowForeSlots = 512;
+	static const TUint KQueryWindowRearSlots = 0;
+	
+	mutable RDbTable						iBatched;
+	mutable RDbTable						iBatched_SuidHashID;
+	mutable RDbNamedDatabase				iDatabase;
+	mutable TBuf<KMTPMaxSqlStatementLen>	iSqlStatement;
+	mutable TUint32							iCachedHandle;
+	mutable TUint32							iCachedSuidHash;
+	
+	RArray<TUint>							iNonPersistentDPList;
+	//The following object is used for enumerating cache, will be closed after the enumeration is completed.
+	RPointerArray<CEnumertingCacheItem>		iEnumeratingCacheObjList;
+	RMTPFramework							iSingletons;
+	
+	
+	TUint32									iTransactionOps;
+	TUint32									iMaxCommitLimit;
+	TUint32									iMaxCompactLimit;
+	TBool									iUpdateDeltaDataTable;
+	TBool									iCacheExist;
+	
+	CMTPReferenceMgr*						iReferenceMgr;
+	CMTPHandleAllocator*					iHandleAllocator;
+	CEnumertingCacheItem*					iSentinal;
+	CMTPDPIDStore*							iDPIDStore;
+	CMTPPkgIDStore*							iPkgIDStore;
+	CMtpDeltaDataMgr* 						iMtpDeltaDataMgr;
+	CDbCompactor*							iCompactor;
+	mutable TFileName                       iSuidBuf;
+	/**
+	 FLOGGER debug trace member variable.
+	 */
+	__FLOG_DECLARATION_MEMBER_MUTABLE;
+	};
+
+#endif // CMTPOBJECTSTORE_H