--- a/mmappcomponents/harvester/filehandler/src/mpxharvesterdbmanager.cpp Tue Feb 02 00:27:58 2010 +0200
+++ b/mmappcomponents/harvester/filehandler/src/mpxharvesterdbmanager.cpp Fri Feb 19 23:18:32 2010 +0200
@@ -21,17 +21,43 @@
#include <pathinfo.h>
#include <driveinfo.h>
#endif //RD_MULTIPLE_DRIVE
+
+#ifdef __RAMDISK_PERF_ENABLE
+#include <centralrepository.h>
+#include <BAUTILS.H>
+#include <mpxharvestercrkeys.h>
+#include "mpxdbcommon.h"
+#endif //__RAMDISK_PERF_ENABLE
+
#include <mpxlog.h>
#include "mpxharvesterdbmanager.h"
#include "mpxharvesterdb.h"
#include "mpxharvesterdbtable.h"
+// CONSTANTS
+#ifdef __RAMDISK_PERF_ENABLE
+_LIT( KHarvesterDummyDBName, "harvesterDummy.dat" );
+const TInt64 KMPMegaByte = 1048576;
+const TInt64 KMPEstimatedSongInBytes = KMPMegaByte * 2;
+const TInt KMPEstimatedSizePerDBEntry = KMaxFileName; // worst scenario, can be lower if needed
+//const TInt KUpdateDBCount = 200;
+const TInt KMPMinimumRAMSizeToRun = 6 * KMPMegaByte;
+#endif //__RAMDISK_PERF_ENABLE
+
+
// ---------------------------------------------------------------------------
// C++ Constructor
// ---------------------------------------------------------------------------
//
-CMPXHarvesterDatabaseManager::CMPXHarvesterDatabaseManager( RFs& aFs )
- : iFs( aFs )
+CMPXHarvesterDatabaseManager::CMPXHarvesterDatabaseManager( RFs& aFs ):
+ iFs( aFs )
+#ifdef __RAMDISK_PERF_ENABLE
+ ,iRAMDiskPerfEnabled(EFalse),
+ iMaximumAllowedRAMDiskSpaceToCopy(0),
+ //iUpdateCount(0),
+ iMtpMode(EFalse)
+ //iMtpAddCount(0)
+#endif //__RAMDISK_PERF_ENABLE
{
}
@@ -43,7 +69,38 @@
//
void CMPXHarvesterDatabaseManager::ConstructL()
{
+ MPX_FUNC("CMPXHarvesterDatabaseManager::ConstructL");
User::LeaveIfError( iDBSession.Connect() );
+
+#ifdef __RAMDISK_PERF_ENABLE
+ TInt temp;
+ CRepository* repository = CRepository::NewLC( KCRUIDMpxHarvesterFeatures );
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::ConstructL got repository");
+ User::LeaveIfError( repository->Get( KMpxHarvesterEnableRamDisk, temp ));
+ iRAMDiskPerfEnabled = temp;
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::ConstructL KMpxHarvesterEnableRamDisk %d", iRAMDiskPerfEnabled);
+
+ User::LeaveIfError( repository->Get( KMpxHarvesterMaxAllowedRamDiskSpace, temp) );
+ iMaximumAllowedRAMDiskSpaceToCopy = temp * KMPMegaByte;
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::ConstructL KMpxHarvesterMaxAllowedRamDiskSpace %Lu", iMaximumAllowedRAMDiskSpaceToCopy);
+ CleanupStack::PopAndDestroy(repository);
+
+ if ( iRAMDiskPerfEnabled )
+ {
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::ConstructL RAMDisk performance is enabled.");
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::ConstructL RAMDisk iMaximumAllowedRAMDiskSpaceToCopy=%Lu", iMaximumAllowedRAMDiskSpaceToCopy);
+ if ( GetRAMDiskPath() != KErrNone )
+ {
+ // Error finding ram drive, disable ram disk
+ iRAMDiskPerfEnabled = EFalse;
+ }
+ }
+ else
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::ConstructL RAMDisk performance is NOT enabled iRAMDiskPerfEnabled=%d", iRAMDiskPerfEnabled);
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::ConstructL RAMDisk iMaximumAllowedRAMDiskSpaceToCopy=%Lu", iMaximumAllowedRAMDiskSpaceToCopy);
+ }
+#endif //__RAMDISK_PERF_ENABLE
}
@@ -68,6 +125,13 @@
//
CMPXHarvesterDatabaseManager::~CMPXHarvesterDatabaseManager()
{
+#ifdef __RAMDISK_PERF_ENABLE
+ TInt count(iDatabases.Count());
+ for (TInt i = 0; i < count; ++i)
+ {
+ RemoveDummyFile(i);
+ }
+#endif // __RAMDISK_PERF_ENABLE
iDatabases.ResetAndDestroy();
iDatabases.Close();
iDBSession.Close();
@@ -189,17 +253,17 @@
//
if (!IsRemoteDrive(aDrive))
{
- TInt count( iDatabases.Count() );
- for( TInt i=0; i<count; ++i )
- {
- CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];
- if( db->GetDbDrive() == aDrive )
+ TInt count( iDatabases.Count() );
+ for( TInt i=0; i<count; ++i )
{
- db->OpenL();
- break;
+ CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];
+ if( db->GetDbDrive() == aDrive )
+ {
+ db->OpenL();
+ break;
+ }
}
}
- }
MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL --->");
}
@@ -415,5 +479,621 @@
MPX_DEBUG1("CMPXHarvesterDatabaseManager::Rollback -->");
}
+#ifdef __RAMDISK_PERF_ENABLE
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::CopyDBsToRamL
+// ---------------------------------------------------------------------------
+//
+void CMPXHarvesterDatabaseManager::CopyDBsToRamL( TBool aMtpMode )
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::CopyDBsToRamL");
+ iMtpMode = aMtpMode;
+ //iMtpAddCount = 0;
+ //iUpdateCount = 0;
+
+ if( iRAMDiskPerfEnabled )
+ {
+ // Check for low ram disk space.
+ if ( !IsRamDiskSpaceAvailable() || IsRamDiskLow() )
+ {
+ return;
+ }
+
+ // Check if we are over the allowed ram space.
+ TInt dbSize=0;
+ TInt err = GetTotalDatabasesSize(dbSize, EFalse);
+ if ( err || (dbSize > iMaximumAllowedRAMDiskSpaceToCopy) )
+ {
+ MPX_DEBUG2("CMPXDbManager::CopyDBsToRamL Over the allowed Ram disk limit %Lu", iMaximumAllowedRAMDiskSpaceToCopy );
+ return;
+ }
+
+ TInt count(iDatabases.Count());
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CopyDBsToRamL() iDatabaseHandles.Count()=%d", count);
+ for (TInt i = 0; i < count; ++i)
+ {
+ TDriveUnit drive( iDatabases[i]->GetDbDrive() );
+ // Don't copy db on C drive.
+ if ( (TInt)drive == EDriveC )
+ {
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::CopyDBsToRamL() Drive C: skipped.");
+ continue;
+ }
+
+ // Check if database is in RAM drive.
+ if ( iDatabases[i]->IsUseRamDrive())
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CopyDBsToRamL Drive %d is already in Ram Drive.", (TInt)drive);
+ continue;
+ }
+
+ // Get the db state in order to restore it later.
+ TDbState dbState = iDatabases[i]->GetDbState();
+ iDatabases[i]->SetDbStateL( EDbClose );
+ TRAPD(err, DoCopyDBToRamL( drive ));
+ if ( err != KErrNone )
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CopyDBsToRamL error=%d", err);
+ // delete dummy file
+ RemoveDummyFile(i);
+
+ // delete db in ram drive
+ TFileName ramDb = GenerateHarvesterDbName( drive, ETrue );
+ TInt delErr = BaflUtils::DeleteFile(iFs, ramDb);
+ MPX_DEBUG3("CMPXHarvesterDatabaseManager::CopyDBsToRamL db on ram drive deleted file=%S, err=%d", &ramDb, delErr);
+
+ iDatabases[i]->SetRamDriveInfo( iRAMDrive, EFalse);
+ }
+ // Restore the db state.
+ iDatabases[i]->SetDbStateL( dbState );
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::DoCopyDBToRamL
+// ---------------------------------------------------------------------------
+//
+void CMPXHarvesterDatabaseManager::DoCopyDBToRamL(TDriveUnit aDriveUnit)
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::DoCopyDBToRamL");
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::DoCopyDBToRamL Database from drive %d", (TInt)aDriveUnit );
+ TFileName dst;
+ TFileName src;
+ dst.Zero();
+ dst.Append(iRAMFolder);
+ BaflUtils::EnsurePathExistsL( iFs, dst );
+ src = GenerateHarvesterDbName( aDriveUnit );
+ MPX_DEBUG2("RAMDisk src path=%S", &src);
+ dst = GenerateHarvesterDbName( aDriveUnit, ETrue );
+ MPX_DEBUG2("RAMDisk dst path=%S", &dst);
+ TEntry entry;
+ iFs.Entry( src, entry );
+ User::LeaveIfError( BlockDiskSpaceL( aDriveUnit, entry.iSize ));
+ User::LeaveIfError( BaflUtils::CopyFile(iFs, src, dst ) );
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::DoCopyDBToRamL Copy to Ram Drive Successful.");
+ GetDatabaseL( (TDriveNumber) (TInt)aDriveUnit ).SetRamDriveInfo(iRAMDrive, ETrue);
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::CopyDBsFromRamL
+// ---------------------------------------------------------------------------
+//
+void CMPXHarvesterDatabaseManager::CopyDBsFromRamL()
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::CopyDBsFromRamL");
+ // Stop monitoring ram drive for low disk space.
+ iMtpMode = EFalse;
+ //iMtpAddCount = 0;
+ //iUpdateCount = 0;
+
+ if( iRAMDiskPerfEnabled )
+ {
+ TInt count(iDatabases.Count());
+ for (TInt i = 0; i < count; ++i)
+ {
+ TInt err = KErrNone;
+ TDriveUnit drive( iDatabases[i]->GetDbDrive() );
+ // Check if database is in RAM drive.
+ if ( !iDatabases[i]->IsUseRamDrive())
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CopyDBsFromRamL Drive %d is NOT in Ram Drive.", (TInt)drive);
+ continue;
+ }
+
+ // Set the UseRamDrive bool to False.
+ iDatabases[i]->SetRamDriveInfo( iRAMDrive, EFalse );
+ // Get the db state in order to restore it later.
+ TDbState dbState = iDatabases[i]->GetDbState();
+ iDatabases[i]->SetDbStateL(EDbClose);
+ TRAP( err, DoCopyDBFromRamL(drive) );
+ if ( err )
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CopyDBsFromRamL copy error=%d", err);
+ //anyting wrong, delete the temp file.
+ RemoveDummyFile(i);
+ }
+
+ // Restore the db state.
+ iDatabases[i]->SetDbStateL( dbState );
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::DoCopyDBFromRamL
+// ---------------------------------------------------------------------------
+//
+void CMPXHarvesterDatabaseManager::DoCopyDBFromRamL(TDriveUnit aDriveUnit)
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL");
+ TFileName dst;
+ TFileName src;
+ TInt err = KErrNone;
+
+ dst = GenerateHarvesterDbName( aDriveUnit );
+ src = GenerateHarvesterDbName( aDriveUnit, ETrue );
+ MPX_DEBUG3("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL from %S to %S", &src, &dst );
+
+ // Rename the temp file into real Db name
+ TFileName dummyDbFileName = GenerateDummyDbName( aDriveUnit );
+
+ //Copy Db from RAM to replace dummy file
+ err = BaflUtils::CopyFile(iFs, src, dummyDbFileName);
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL database copied from ram drive err=%d.", err);
+
+ // delete db in ram drive.
+ TInt delErr = BaflUtils::DeleteFile(iFs, src);
+ MPX_DEBUG3("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL db on ram drive deleted file=%S, err=%d", &src, delErr);
+
+ // Make sure we del db from ram drive before leaving.
+ User::LeaveIfError( err );
+
+ // Delete existing DB on drive
+ delErr = BaflUtils::DeleteFile(iFs, dst);
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL destination file deleted err=%d", delErr);
+
+ // rename dummy file to real db name
+ User::LeaveIfError( BaflUtils::RenameFile(iFs, dummyDbFileName, dst) );
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL dummy file renamed.");
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::GetRAMDiskPath
+// ---------------------------------------------------------------------------
+//
+TInt CMPXHarvesterDatabaseManager::GetRAMDiskPath()
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::GetRAMDiskPath");
+ TDriveList driveList;
+ TBool ramDriveFound = EFalse;
+ iRAMFolder.Zero();
+
+ TInt error = iFs.DriveList( driveList );
+ if ( error == KErrNone )
+ {
+ for ( TInt i = 0; i < driveList.Length(); i++ )
+ {
+ if ( driveList[i] != 0 )
+ {
+ TDriveInfo info;
+ TInt err = iFs.Drive( info, i );
+ if ( !err && info.iType == EMediaRam )
+ {
+ TDriveUnit driveUnit( i );
+ iRAMDrive = (TDriveNumber)i;
+ iRAMFolder.Append(driveUnit.Name());
+ iRAMFolder.Append(KHarvesterDBPath);
+ ramDriveFound = ETrue;
+ MPX_DEBUG2("RAMDisk path=%S", &iRAMFolder);
+ break;
+ }
+ }
+ }
+
+ // Check if ram drive is found.
+ if ( !ramDriveFound )
+ {
+ error = KErrNotFound;
+ }
+ }
+ MPX_DEBUG2("CMPXDbManager::GetRAMDiskPath Get DriveList error=%d", error);
+ return error;
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::IsRamDiskSpaceAvailable
+// ---------------------------------------------------------------------------
+//
+TBool CMPXHarvesterDatabaseManager::IsRamDiskSpaceAvailable()
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::IsRamDiskSpaceAvailable");
+ TVolumeInfo vol;
+ TInt err = iFs.Volume( vol, iRAMDrive );
+ if ( err != KErrNone )
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::IsRamDiskSpaceAvailable Disk Not available to use. Error = %d", err);
+ return EFalse;
+ }
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::IsRamDiskSpaceAvailable Free in bytes =%Lu", vol.iFree);
+ if ( vol.iFree > KMPMinimumRAMSizeToRun )
+ {
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::IsRamDiskSpaceAvailable Ok to copy");
+ return ETrue;
+ }
+
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::IsRamDiskSpaceAvailable NOT Ok to copy");
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::BlockDiskSpaceL
+// ---------------------------------------------------------------------------
+//
+TInt CMPXHarvesterDatabaseManager::BlockDiskSpaceL( TDriveUnit aDrive, TInt aOrigDbSize )
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::BlockDiskSpaceL");
+
+ // if current DB size can not fit in RAM, abort now
+ TVolumeInfo vol;
+ TInt err = KErrNone;
+ err = iFs.Volume( vol, iRAMDrive );
+ if ( err )
+ {
+ return err;
+ }
+
+ if ( vol.iFree < aOrigDbSize + KMPMinimumRAMSizeToRun )
+ {
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::BlockDiskSpaceL Not enough space on ram drive." );
+ return KErrDiskFull;
+ }
+
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::BlockDiskSpaceL %d", (TInt)aDrive );
+ err = iFs.Volume( vol, (TInt)aDrive );
+ if ( err )
+ {
+ return err;
+ }
+
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::BlockDiskSpaceL Disk total free space in bytes =%Lu", vol.iFree);
+ TInt64 blockingSize( CalculateInitalDummyDBSizeL( vol, aOrigDbSize ));
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::BlockDiskSpaceL Disk blocking size =%Lu", blockingSize);
+ // Pad blockingSize by 1Mb so we don't use all the free disk space.
+ if ( vol.iFree > (blockingSize + 1*KMPMegaByte) )
+ {
+ TFileName dummyDbFileName = GenerateDummyDbName( aDrive );
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::BlockDiskSpaceL Dummy db file name=%S", &dummyDbFileName);
+
+ RFile dummyDb;
+ err = dummyDb.Replace( iFs, dummyDbFileName, EFileWrite );
+ if (err != KErrNone)
+ {
+ MPX_DEBUG2("CMPXDbManager::BlockDiskSpaceL Can't open dummy file %d", err);
+ return err;
+ }
+
+ err = dummyDb.SetSize( blockingSize );
+ // Close the dummy RFile
+ dummyDb.Close();
+ if ( err )
+ {
+ MPX_DEBUG2("CMPXDbManager::BlockDiskSpaceL Can't resize dummy file %d", err);
+ return err;
+ }
+ }
+ else
+ {
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::BlockDiskSpaceL - Not enough disk space for dummy file.");
+ err = KErrDiskFull;
+ }
+ return err;
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSizeL
+// ---------------------------------------------------------------------------
+//
+TInt64 CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSizeL( TVolumeInfo aVol, TInt aOrigDbSize )
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSizeL");
+ TInt64 size;
+
+ if ( iMtpMode )
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSize aVol.iFree=%Lu", aVol.iFree );
+ TInt64 totalNumOfSongsCanFit = aVol.iFree / KMPEstimatedSongInBytes;
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSize (MTP) totalNumOfSongsCanFit=%Lu", totalNumOfSongsCanFit );
+ TInt64 estimatedSize = totalNumOfSongsCanFit * (TInt64) KMPEstimatedSizePerDBEntry + aOrigDbSize;
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSize (MTP) estimated DB size from calculation=%Lu", estimatedSize );
+ if ( estimatedSize > iMaximumAllowedRAMDiskSpaceToCopy )
+ {
+ size = iMaximumAllowedRAMDiskSpaceToCopy;
+ }
+ else
+ {
+ size = estimatedSize;
+ }
+ }
+ else
+ {
+ TInt64 totalNumOfSongsCanFit = aVol.iSize / KMPEstimatedSongInBytes;
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSize totalNumOfSongsCanFit=%Lu", totalNumOfSongsCanFit );
+ TInt64 estimatedSize = totalNumOfSongsCanFit * (TInt64) KMPEstimatedSizePerDBEntry + aOrigDbSize;
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSize estimated DB size from calculation=%Lu", estimatedSize );
+ if ( estimatedSize > iMaximumAllowedRAMDiskSpaceToCopy )
+ {
+ size = iMaximumAllowedRAMDiskSpaceToCopy;
+ }
+ else
+ {
+ size = estimatedSize;
+ }
+ }
+
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::CalculateInitalDummyDBSize Dummy DB size=%Lu", size );
+ return size;
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::RemoveDummyFile
+// ---------------------------------------------------------------------------
+//
+void CMPXHarvesterDatabaseManager::RemoveDummyFile( TInt aIndex )
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::RemoveDummyFile");
+
+ TDriveUnit driveUnit(iDatabases[aIndex]->GetDbDrive());
+ TFileName file = GenerateDummyDbName(driveUnit);
+
+ if ( (file.Length() > 0) &&
+ (BaflUtils::FileExists(iFs, file)) )
+ {
+ BaflUtils::DeleteFile(iFs, file);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::UpdateDBsFromRamL
+// ---------------------------------------------------------------------------
+//
+/*void CMPXHarvesterDatabaseManager::UpdateDBsFromRamL( TInt aCount )
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::UpdateDBsFromRamL");
+ TBool updateDb = EFalse;
+
+ // In MTP mode, aCount is invalid, songs are added one at a time.
+ if ( iMtpMode )
+ {
+ iMtpAddCount++;
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::UpdateDBsFromRamL iMtpAddCount=%d", iMtpAddCount);
+ if ( (iMtpAddCount - iUpdateCount) > KUpdateDBCount )
+ {
+ updateDb = ETrue;
+ iUpdateCount = iMtpAddCount;
+ }
+ }
+ else
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::UpdateDBsFromRamL aCount=%d", aCount);
+ if ( (aCount - iUpdateCount) > KUpdateDBCount )
+ {
+ updateDb = ETrue;
+ iUpdateCount = aCount;
+ }
+ }
+
+ if ( updateDb )
+ {
+ CommitL();
+ TInt count(iDatabases.Count());
+ for (TInt i = 0; i < count; ++i)
+ {
+ TDriveUnit drive( iDatabases[i]->GetDbDrive() );
+ // Check if database is not in RAM drive.
+ if ( !iDatabases[i]->IsUseRamDrive() )
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::UpdateDBsFromRamL Drive %d is not in Ram Drive.", (TInt)drive);
+ continue;
+ }
+
+ iDatabases[i]->Close();
+ // update the database from ram drive.
+ TRAP_IGNORE( DoUpdateDBFromRamL( drive ) );
+ //
+ iDatabases[i]->OpenL();
+ }
+ BeginL();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::DoUpdateDBFromRamL
+// ---------------------------------------------------------------------------
+//
+void CMPXHarvesterDatabaseManager::DoUpdateDBFromRamL(TDriveUnit aDriveUnit)
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::DoUpdateDBFromRamL");
+
+ TFileName dst;
+ TFileName src;
+
+ dst = GenerateHarvesterDbName( aDriveUnit );
+ src = GenerateHarvesterDbName( aDriveUnit, ETrue );
+ MPX_DEBUG3("CMPXHarvesterDatabaseManager::DoUpdateDBFromRamL from %S to %S", &src, &dst );
+
+ //Copy Db from RAM to real db file
+ TInt err = BaflUtils::CopyFile(iFs, src, dst);
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::DoUpdateDBFromRamL database copied from ram drive err=%d.", err);
+ }*/
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::GenerateHarvesterDbName
+// ---------------------------------------------------------------------------
+//
+TFileName CMPXHarvesterDatabaseManager::GenerateHarvesterDbName( TDriveUnit aDriveUnit, TBool aForRamDrive )
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::GenerateHarvesterDbName");
+ TFileName name;
+ name.Zero();
+
+ if ( aForRamDrive )
+ {
+ name.Append(iRAMFolder);
+ name.Append(aDriveUnit.Name()[0]);
+ name.Append(KHarvesterDBName);
+ }
+ else
+ {
+ name.Append(aDriveUnit.Name());
+ name.Append(KHarvesterDBPath);
+ name.Append(KHarvesterDBName);
+ }
+
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::GenerateHarvesterDbName name = %S", &name );
+ return name;
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::GenerateDummyDbName
+// ---------------------------------------------------------------------------
+//
+TFileName CMPXHarvesterDatabaseManager::GenerateDummyDbName( TDriveUnit aDriveUnit )
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::GenerateDummyDbName");
+ TFileName name;
+ name.Zero();
+ name.Append(aDriveUnit.Name());
+ name.Append(KHarvesterDBPath);
+ name.Append(KHarvesterDummyDBName);
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::GenerateDummyDbName name = %S", &name );
+ return name;
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::EnsureRamSpaceL
+// ---------------------------------------------------------------------------
+//
+void CMPXHarvesterDatabaseManager::EnsureRamSpaceL()
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::EnsureRamSpaceL()");
+
+ // Ram disk disabled, no need to continue.
+ if( !iRAMDiskPerfEnabled )
+ {
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::EnsureRamSpaceL RAM Disk Disabled.");
+ return;
+ }
+
+ // Check if any DBs are in RAM drive.
+ TInt count(iDatabases.Count());
+ TBool ramDriveInUse = EFalse;
+ for (TInt i = 0; i < count; ++i)
+ {
+ // Check if database is in RAM drive.
+ if ( iDatabases[i]->IsUseRamDrive() )
+ {
+ ramDriveInUse = ETrue;
+ break;
+ }
+ }
+
+ // DBs not in ram drive, no need to continue.
+ if ( !ramDriveInUse )
+ {
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::EnsureRamSpaceL No DBs in RAM drive.");
+ return;
+ }
+
+ // Check if low on Ram disk.
+ if ( IsRamDiskLow() )
+ {
+ // RAM not enough, copy back to normal drive and continue to harvest.
+ MPX_DEBUG1("CMPXHarvesterDatabaseManager::EnsureRamSpaceL RAM diskspace is full, copy dbs back.");
+ CopyDBsFromRamL();
+ }
+ else
+ {
+ TInt size=0;
+ TInt err = GetTotalDatabasesSize(size, ETrue);
+ if ( err || (size > iMaximumAllowedRAMDiskSpaceToCopy) )
+ {
+ // Databases using too much RAM space, copy back to normal drive and continue to harvest.
+ if ( err )
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::EnsureRamSpaceL Get DBs Size Err = %d, copy dbs back.", err);
+ }
+ else
+ {
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::EnsureRamSpaceL DBs using too much RAM space size = %d, copy dbs back.", size);
+ }
+ CopyDBsFromRamL();
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::IsRamDiskLow
+// ---------------------------------------------------------------------------
+//
+TBool CMPXHarvesterDatabaseManager::IsRamDiskLow()
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::IsRamDiskLow()");
+ TBool low = EFalse;
+ TVolumeInfo vol;
+ TInt errRAM = iFs.Volume( vol, iRAMDrive );
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::IsRamDiskLow Get vol err: %d", errRAM);
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::IsRamDiskLow Free RAM Disk Space: %Lu", vol.iFree);
+ if ( errRAM == KErrNone && vol.iFree < KMPMinimumRAMSizeToRun )
+ {
+ low = ETrue;
+ }
+ return low;
+ }
+
+// ---------------------------------------------------------------------------
+// CMPXHarvesterDatabaseManager::GetTotalDatabasesSize
+// ---------------------------------------------------------------------------
+//
+TInt CMPXHarvesterDatabaseManager::GetTotalDatabasesSize(TInt& aSize, TBool aRamDrive)
+ {
+ MPX_FUNC("CMPXHarvesterDatabaseManager::GetTotalDatabasesSize");
+ TInt err = KErrNone;
+ TInt size=0;
+ TInt count(iDatabases.Count());
+ for ( TInt i = 0; i < count ; ++i )
+ {
+ TDriveUnit drive( iDatabases[i]->GetDbDrive() );
+ // Ignore C drive
+ if ( (TInt)drive == EDriveC )
+ {
+ continue;
+ }
+ // Generate database name.
+ TFileName dbFilename = GenerateHarvesterDbName(drive, aRamDrive);
+ MPX_DEBUG2("CMPXHarvesterDatabaseManager::GetTotalDatabasesSize - Database name = %S", &dbFilename);
+ TEntry entry;
+ err = iFs.Entry( dbFilename, entry );
+ if (err == KErrNotFound || err == KErrNotReady)
+ {
+ MPX_DEBUG3("CMPXHarvesterDatabaseManager::GetTotalDatabasesSize - Ignored %S, err = %d", &dbFilename, err);
+ err = KErrNone;
+ continue;
+ }
+ if ( err != KErrNone )
+ {
+ break;
+ }
+ MPX_DEBUG3("CMPXHarvesterDatabaseManager::GetTotalDatabasesSize - Size of Db %S = %d", &dbFilename, entry.iSize);
+ // sum up size
+ size += entry.iSize;
+ }
+ aSize = size;
+ MPX_DEBUG3("CMPXHarvesterDatabaseManager::GetTotalDatabasesSize - Total Size of Dbs = %d, err = %d", size, err);
+ return err;
+ }
+
+#endif // __RAMDISK_PERF_ENABLE
+
// END OF FILE