diff -r 14979e23cb5e -r 3de6c4cf6b67 mpxplugins/serviceplugins/collectionplugins/inc/mpxdbmanager.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mpxplugins/serviceplugins/collectionplugins/inc/mpxdbmanager.h Wed Sep 01 12:32:02 2010 +0100 @@ -0,0 +1,651 @@ +/* +* Copyright (c) 2007 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: This class is responsible for managing all of music collection +* databases. +* +*/ + + +#ifndef MPXDBMANAGER_H +#define MPXDBMANAGER_H + +// INCLUDES + +#include +#include +#include +#include + +// FORWARD DECLARATIONS + +class MMPXTable; +class RSqlStatement; + +// CONSTANTS + +const TInt KDbManagerAllDrives = 0; + +// CLASS DECLARATION + +/** +* Generic class responsible for managing databases on multiple drives. +* +* @lib MPXDbPlugin.lib +*/ +class CMPXDbManager : + public CBase + { + protected: // Constructors + + /** + * C++ default constructor + * @param aFs file server session + */ + IMPORT_C CMPXDbManager(RFs& aFs); + + /** + * The second phase constructor to safely construct things + * that can leave + * @param aDatabaseFile database filename + */ + IMPORT_C void ConstructL(const TFileName& aDatabaseFile); + + public: + + /** + * Destructor + */ + IMPORT_C virtual ~CMPXDbManager(); + + public: // New methods + + /** + * Checks if all databases have been initialized. + * @return ETrue if initialized, EFalse otherwise + */ + IMPORT_C TBool IsInitialized(); + + /** + * Begins a transaction on all databases. + */ + IMPORT_C void BeginL(); + + /** + * Commits a transaction on all databases. + */ + IMPORT_C void CommitL(); + + /** + * Rolls back a transaction on all databases. + */ + IMPORT_C void RollbackL(); + + /** + * Checks if the database is currently in a transaction + * + * @return ETrue if database is currently in a transaction, EFalse otherwise + */ + IMPORT_C TBool InTransaction(); + + /** + * Tries to create and open the databases on all specified drives. + * If a drive is not valid (like an MC not plugged in) it will be skipped. + * @param aDrives array of drives to create and open databases on. + */ + IMPORT_C void InitDatabasesL(RArray aDrives); + + /** + * Opens a specified database. + * @param aDrive identifies the drive index of the database to open + */ + IMPORT_C void OpenDatabaseL(TInt aDrive); + + /** + * Closes a specified database. + * @param aDrive identifies the drive index of the database to close + */ + IMPORT_C void CloseDatabaseL(TInt aDrive); + + /** + * Closes all open databases. + */ + IMPORT_C void CloseAllDatabases(); + + /** + * Opens all open databases. + */ + IMPORT_C void OpenAllDatabasesL(); + + /** + * Checks if the database on a specified drive is open. + * @param aDrive identifies the drive index of the database to check + * @return ETrue if the database is open, EFalse otherwise + */ + IMPORT_C TBool IsOpen(TInt aDrive) const; + + /** + * Returns the number of currently open databases. + * @return Number of databases + */ + IMPORT_C TInt DatabaseCount() const; + + /** + * Returns the drive corresponding to a give index. + * @param aIndex identifies the index in the list of drives the database uses + * @return Drive index the database uses. + */ + IMPORT_C TInt DbDrive(TInt aIndex) const; + + /** + * Recreate a specified database. + * @param aDrive identifies the drive index ro recreate the database + */ + IMPORT_C void RecreateDatabaseL(TInt aDrive); + + /** + * Recreate all databases. + */ + IMPORT_C void RecreateAllDatabasesL(); + + /** + * Return current DB version + * @return the version of db structure + */ + IMPORT_C TVersion Version() const; + + /** + * Return current DB version + * @return the version of db structure + */ + IMPORT_C void RegisterTableL(MMPXTable& aTable); + + /** + * Executes a select query with variable number of parameters on all + * available drives. + * @param aFmt query format string + * @return resulted result set + */ + IMPORT_C RSqlStatement ExecuteSelectQueryL(TRefByValue aFmt, ...); + + /** + * Executes a select query with variable number of parameters + * against a specified drive + * @param aDrive to execute query on + * @param aFmt query format string + * @return resulted result set + */ + IMPORT_C RSqlStatement ExecuteSelectQueryL(TInt aDrive, TRefByValue aFmt, + ...); + + /** + * Executes a select query with variable number of parameters + * on all available drives. Two values will be bound to the statement + * @param aStatementId unique id of a statement to bind to + * creates a new statement if the id is not found + * @param aFirstValue TInt Value to bind as first argument + * @param aSecondValue TInt Value to bind as second argument + * @param aFmt query format string + * @return resulted result set. The ownership is not passed so the caller should + * not destroy this as it may be reused in future calls. + */ + IMPORT_C RSqlStatement& ExecuteSelectQueryL( TUint aStatementId, + TInt aFirstValue, TInt aSecondValue, + TRefByValue aFmt, ...); + + /** + * Executes a select query with variable number of parameters + * on all available drives. Two values will be bound to the statement + * @param aStatementId unique id of a statement to bind to + * creates a new statement if the id is not found + * @param aFirstValue TDesC Value to bind as first argument + * @param aSecondValue TInt Value to bind as second argument + * @param aFmt query format string + * @return resulted result set. The ownership is not passed so the caller should + * not destroy this as it may be reused in future calls. + */ + IMPORT_C RSqlStatement& ExecuteSelectQueryL( TUint aStatementId, + const TDesC& aFirstValue, + TInt aSecondValue, + TRefByValue aFmt, ...); + /** + * Executes a query that does not return a record set + * @param aDrive to execute query on + * @param aFmt query format string + */ + IMPORT_C void ExecuteQueryL(TInt aDrive, TRefByValue aFmt, ...); + + /** + * Prints the contents of all the databases to the log file + * @param aDrive to execute query on + */ + IMPORT_C void PrintDatabaseL(); + + /** + * Returns the file server session. + * @return file server session + */ + IMPORT_C RFs& Fs(); + + /** + * Checks if the space on the specified drive(s) is above the critical level + * @param aDrive drive ID or KDbManagerAllDrives + * @leave KErrDiskFull if the space on the specified drive(s) is below the + * critical level + */ + IMPORT_C void CheckDiskSpaceL(TInt aDrive); + + /** + * Completely recreate all databases. + */ + IMPORT_C void RegenerateAllDatabasesL(); + + /** + * Checks if the spefified drive is a remove drive + */ + IMPORT_C TBool IsRemoteDrive(TDriveNumber aDrive); + + protected: + + /** + * Creates a database on a specified drive. + * @param aDrive identifies the database + */ + IMPORT_C void CreateDatabaseL(TInt aDrive); + + /** + * Remove the database + * @param aDrive identifies the database + */ + IMPORT_C void RemoveDatabaseL(TInt aDrive); + + /** + * Create the all tables + * @param aDatabase the database to add tables to + */ + IMPORT_C void CreateTablesL(RSqlDatabase& aDatabase); + + /** + * Drop all tables + * @param aDatabase the database to drop tables from + */ + IMPORT_C void DropTablesL(RSqlDatabase& aDatabase); + + public: + + /** + * Executes a select query with variable number of parameters + * against a specified drive + * @param aDrive to execute query on + * @param aFmt query format string + * @return resulted result set + */ + IMPORT_C RSqlStatement ExecuteSelectQueryOnAllDrivesL(TInt aDrive, TRefByValue aFmt, + ...); + + /** + * Copy all databases from RAM disk back to normal drive, E, F,... + * + * @return none + */ + IMPORT_C void CopyDBsFromRamL(); + + /** + * Copy all databases to RAM disk back from normal drive, E, F,... + * + * @return none + */ + IMPORT_C void CopyDBsToRamL( TBool aIsMTPInUse = EFalse); + + + /** + * Check if RAM disk is enough to operatte. If not, DBs will be copied back to drives. + * + * @return TInt index to the database handler + */ + IMPORT_C void EnsureRamSpaceL() ; + + /** + * Move DBs from RAMDisk to disks + */ + //IMPORT_C void BackupDBsL(); + + private: + + /** + * Find available RAMDISK + * @return error code + */ + TInt GetRAMDiskPath(); + + /** + * Check if RAM disk is available to copy. + * + * @return ETrue if there is enough space, EFalse otherwise + */ + TBool IsRamDiskSpaceAvailable(); + + /** + * To block a diskspace so that it can gurantee for a write back from RAM disk + * + * @return ETrue if the dummy file is created successfully, EFalse otherwise + */ + TBool BlockDiskSpace( TInt aIndex, TBool aIsMTPInUse = EFalse ); + + /** + * To copy db from regular drive to RAM + * + * @return ETrue if succeed + * + * No-operation if fails + */ + TBool DoCopyDBToRam( TInt aIndex, TBool aIsMTPInUse ); + + /** + * To copy db back regular drive from RAM + * + */ + void DoCopyDBFromRam( TInt aIndex ); + + /** + * To replace dummy file with new content + * Writes over previous dummy file without freeing disk space + */ + void ReplaceFileL( const TDesC& aSrcName, const TDesC& aDstName ); + + /** + * To calculate necessary file size of the dummy file + * + * @return TInt64 estimated file size + */ + TInt64 CalculateInitalDummyDBSize( const TVolumeInfo& aVol, TInt aOrigDbSize, TBool aIsMTPInUse = EFalse); + + /** + * Get database index by giving drive index + * + * @return TInt index to the database handler + */ + TInt GetDatabaseIndex(TInt aDrive); + + /** + * Sum up the total size in bytes of the databases. + * + * @param aSize - On return, the total size of the databases. + * @return TInt System error. + */ + TInt GetTotalDatabasesSize(TInt& aSize); + + /** + * Sum up the total size in bytes of the databases on the RAM drive. + * + * @param aSize - On return, the total size of the databases on the RAM drive. + * @return TInt System error. + */ + TInt GetTotalRamDatabasesSizeL(TInt& aSize); + + /** + * Remove dummy file + * + * @return TInt index to the database handler + */ + void RemoveDummyFile( TInt index ); + + /** + * Check if disksapce is enough to operatte. If not, it leaves with KErrDiskFull + * + */ + void EnsureDiskSpaceL(TInt aDrive) ; + + /** + * Begin transaction, leaves on error + */ + void DoBeginL(); + + /** + * Commit transaction, leaves on error + */ + void DoCommitL(); + + /** + * Create full path and filename on a specified drive unit. + * @param aDrive identifies the drive unit + */ + HBufC* CreateFullFilenameL(TDriveUnit aDrive); + + protected: // Types + + typedef struct + { + TInt iDrive; + TBool iOpen; + HBufC* iAliasname; +#ifdef __RAMDISK_PERF_ENABLE + TBool iUseRAMdb; + HBufC* iOrigFullFilePath; + HBufC* iTargetFullFilePath; + TFileName iDummyFilePath; +#endif //__RAMDISK_PERF_ENABLE + } DatabaseHandle; + + protected: // Data + + HBufC* iDbFile; + RArray iTables; + RSqlDatabase iDatabase; + RArray iDatabaseHandles; + + private: + + /** + * Create the all tables + * @param aDatabase the database to add tables to + * @param aCorrupt specifies whether the database is corrupted or not + */ + void CreateTablesL(RSqlDatabase& aDatabase, TBool aCorrupt); + + /** + * Opens root database at C-drive. + */ + void OpenRootDatabaseL(); + + /** + * Creates a specified database. + * @param aDrive identifies the drive unit of the database to create + */ + void CreateDatabaseL(TDriveUnit aDrive); + + /** + * Attached a specified database. + * @param aIndex Index to iDatabaseHandles + */ + void AttachDatabaseL(TInt aIndex); + + /** + * Detach a specified database. + * @param aIndex Index to iDatabaseHandles + */ + void DetachDatabaseL(TInt aIndex); + + /** + * Open database + * @param aIndex Index to iDatabaseHandles + */ + void OpenDatabaseAtIndexL( TInt aIndex ); + + /** + * Close database + * @param aIndex Index to iDatabaseHandles + */ + void CloseDatabaseAtIndexL(TInt aIndex); + + /** + * Create filename on a specified drive unit. + * @param aDrive identifies the drive unit + */ + HBufC* CreateFilenameL(TDriveUnit aDrive); + + + /** + * Replaces specially formatted query symbols with a specified alias. + * @param aAlias identifies the alias name to use in query + */ + void ReplaceDriveAlias(TDes& aQuery, const TDesC& aAlias); + + /** + * Replaces specially formatted query symbols with a specified alias. + * @param aAlias identifies the alias name to use in query + * @param aToKen replace by aAlias + */ + void ReplaceDriveAlias(TDes& aQuery, const TDesC& aAlias, const TDesC& aToKen); + + /** + * Removes specially formatted query symbols from the query + * @param aQuery identifies the query to remove specially formatted symbols + */ + void RemoveDriveAlias(TDes& aQuery); + + /** + * Removes specially formatted query symbols from the query + * @param aQuery identifies the query to remove specially formatted symbols + * @param aToKen identifies need remove string + */ + void RemoveDriveAlias(TDes& aQuery, const TDesC& aToKen); + + /** + * Attempts to recreate database by dropping and creating tables + * used inside RecreateDatabaseL + * @param aFilename database filename + */ + void DoRecreateDatabaseL(HBufC * aFilename); + + /** + * Executes SQL statement against the database. + * + * @param aDatabase database handle + * @param aStatement sql statement buffer + * @return KErrNone if successfull, error code otherwise. + * + */ + TInt ExecuteSqlStatement(RSqlDatabase& aDatabase, const TDesC& aStatement); + + /** + * Formats the query. + * @param aFmt query format + * @param aList variable parameter list + * @return formatted query, the ownership is transferred. + */ + HBufC* FormatQueryLC(TRefByValue aFmt, VA_LIST aList); + + /** + * Executes an SQL query on all drives + * @param aQuery query string + * @return prepared SQL statement + */ + RSqlStatement ExecuteSelectQueryOnAllDrivesL(TPtr aQuery); + + /** + * Executes an SQL query on all drives + * @param aDrive drive to execute the query on + * @param aQuery query string + * @return prepared SQL statement + */ + RSqlStatement ExecuteSelectQueryOnAllDrivesL(TInt aDrive,TPtr aQuery); + + /** + * Executes an SQL query on a specified drive + * @param aDrive drive to execute the query on + * @param aQuery query string + * @return prepared SQL statement + */ + RSqlStatement ExecuteSelectQueryOnDriveL(TInt aDrive, TPtr aQuery); + + /** + * Prepares an sql query given the statment + * @param aStatementId unique identifier of the statement + * @param aFmt query format string + * @param aList variable parameter list + * @return reference to the SQL statement + */ + RSqlStatement& PrepareQueryL( TUint aStatementId, + TRefByValue aFmt, + VA_LIST aList ); + + /** + * Resets all prepared queries + */ + void ResetPreparedQueries(); + + /** + * Create Database + */ + void DoCreateDatabaseL( TDriveUnit aDrive ); + +#ifdef _DEBUG + + /** + * Returns the number of columns from a specified SQL statement + * @param aStatement identifies the SQL query to check + */ + TInt GetColumnCountL(RSqlStatement& aStatement); + + /** + * Prints the table of results from a specified SQL query to the debug log + * @param aStatement identifies the SQL query made + */ + void PrintTableValuesL(RSqlStatement& aStatement); + + /** + * Finds all the tables on the main or attached drives + * @param aAlias identifies the alias name to use if a attached drive KNullDesC if main drive + * @param aTableName identifies the array of table names on the main or attached drive + */ + void FindAllTablesL(const TDesC& aAlias, RArray& aTableName); + + /** + * Prints the table on the main or attached drives + * @param aAlias identifies the alias name to use if a attached drive KNullDesC if main drive + * @param aTableName identifies the table name on the main or attached drive + */ + void PrintTableL(const TDesC& aAlias, const TDesC& aTableName); + +#endif + private: + + /* + * Structure to hold the state of a sql statement + */ + NONSHARABLE_STRUCT( TSqlStatementState ) + { + TBool iPrepared; + TUint iId; + }; + + private: + + TBool iInitialized; + TInt iTransactionCount; + RFs& iFs; + + RArray iPreparedStatements; + RPointerArray iStatements; + + // Defined for RAM disk performance + TBool iRAMDiskPerfEnabled; // flag to indicate RAM disk feature is enabled from cenrep. + TUint64 iMaximumAllowedRAMDiskSpaceToCopy; // maximum number of megabytes allow to do RAM disk operation. + TFileName iRAMFolder; + TChar iRAMDrive; + TBool iRAMInUse; + TInt64 iEstimatedDBSizes; + }; + +#endif // MPXDBMANAGER_H