/*

* Copyright (c) 2006 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:  Harvester database manager

*

*/

#include <e32base.h>

#include <pathinfo.h>

#include <driveinfo.h>

#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 ),

        iEMMC( EFalse )

#ifdef __RAMDISK_PERF_ENABLE

        ,iRAMDiskPerfEnabled(EFalse),

        iMaximumAllowedRAMDiskSpaceToCopy(0),

        //iUpdateCount(0),

        iMtpMode(EFalse)

        //iMtpAddCount(0)

#endif //__RAMDISK_PERF_ENABLE

    {

    }

// ---------------------------------------------------------------------------

// 2nd Phase Constructor

// ---------------------------------------------------------------------------

//

void CMPXHarvesterDatabaseManager::ConstructL()

    {

    MPX_FUNC("CMPXHarvesterDatabaseManager::ConstructL");

    User::LeaveIfError( iDBSession.Connect() );

    //Find out if the system has an internal drive (eMMC)

    TDriveInfo driveInfo;

    if( iFs.Drive( driveInfo, EDriveE ) == KErrNone )

    	{

        if ( driveInfo.iDriveAtt & KDriveAttInternal )

        	iEMMC = ETrue;

    	}

#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

    }

// ---------------------------------------------------------------------------

// Two-Phased Constructor

// ---------------------------------------------------------------------------

//

CMPXHarvesterDatabaseManager* CMPXHarvesterDatabaseManager::NewL( RFs& aFs )

    {

    CMPXHarvesterDatabaseManager* self =

                             new( ELeave ) CMPXHarvesterDatabaseManager( aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CMPXHarvesterDatabaseManager::~CMPXHarvesterDatabaseManager()

    {

#ifdef __RAMDISK_PERF_ENABLE

    TInt count(iDatabases.Count());

    for (TInt i = 0; i < count; ++i)

        {

        RemoveDummyFile(iDatabases[i]->GetDbDrive());

        }

#endif // __RAMDISK_PERF_ENABLE

    iDatabases.ResetAndDestroy();

    iDatabases.Close();

    iDBSession.Close();

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::OpenAllDatabasesL

// ---------------------------------------------------------------------------

//

TInt CMPXHarvesterDatabaseManager::OpenAllDatabasesL()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenAllDatabasesL <---");

    TInt rtn (KErrNone);

    // Open drives we are interested in.

    //

    TDriveList driveList;

    TInt driveCount(0);

    User::LeaveIfError( DriveInfo::GetUserVisibleDrives(

           iFs, driveList, driveCount ) );

    for( TInt driveNum = EDriveA; driveNum <= EDriveZ; driveNum++ )

        {

        if (driveList[driveNum] && IsLocalDrive(static_cast<TDriveNumber>(driveNum)))

            {

            MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: opening database in drive %d", driveNum);

            TInt index = FindDatabaseIndex ( (TDriveNumber) driveNum );

            if ( index == KErrNotFound )

                {

                MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: re-creating database");

                CMPXHarvesterDB* dB = CMPXHarvesterDB::NewL(

                    static_cast<TDriveNumber>(driveNum), iFs, iEMMC );

                CleanupStack::PushL( dB );

                TRAPD(openError, rtn |= dB->OpenL() );  //lint !e665

                if(openError == KErrNone)

                    {

                     iDatabases.AppendL( dB );

                     CleanupStack::Pop( dB );

                    }

                else

                    {

                    MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: opening failed, error=%d, removing database", openError);

                    CleanupStack::PopAndDestroy( dB );

                    }

                }

            else

                {

                CMPXHarvesterDB* dB = iDatabases[index];

                TRAPD(openError, rtn |= dB->OpenL() );   //lint !e665

                if(openError != KErrNone)

                    {

                    MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: opening failed, error=%d, removing database", openError);

                    iDatabases.Remove ( index );

                    delete dB;

                    }

                }

            }

        }

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenAllDatabasesL --->");  //lint !e961

    return rtn;

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::OpenDatabaseL

// ---------------------------------------------------------------------------

//

void CMPXHarvesterDatabaseManager::OpenDatabaseL( TDriveNumber aDrive )

    {

    MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenDatabaseL %d <---", aDrive);

    if ( ! IsLocalDrive( aDrive ) )

        {

        MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL drive not available -->");

        return;

        }

    CMPXHarvesterDB * db = NULL;

    TInt index = FindDatabaseIndex ( aDrive );

    if ( index == KErrNotFound )

        {

        index = iDatabases.Count();

        db = CMPXHarvesterDB::NewL( aDrive, iFs, iEMMC );

        CleanupStack::PushL( db );

        iDatabases.AppendL( db );

        CleanupStack::Pop( db );

        }

    else

        {

        db = iDatabases[index];

        }

    // TRAPD(openError, rtn |= dB->OpenL() );  //lint !e665

    TRAPD( openError, db->OpenL() );

    if( openError != KErrNone )

        {

        MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: opening failed, error=%d", openError);

        iDatabases.Remove(index);

        delete db;

        }

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL --->");

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::CloseAllDatabases

// ---------------------------------------------------------------------------

//

void CMPXHarvesterDatabaseManager::CloseAllDatabases()

    {

    // Close all databases for shutdown

    iDatabases.ResetAndDestroy();

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::CloseMassStorageDatabases

// ---------------------------------------------------------------------------

//

void CMPXHarvesterDatabaseManager::CloseMassStorageDatabases()

    {

    MPX_FUNC("CMPXHarvesterDatabaseManager::CloseMassStorageDatabases");

    for (TInt i = 0; i < iDatabases.Count();)

        {

        CMPXHarvesterDB * db =iDatabases [i];

        TDriveNumber drive = db->GetDbDrive();

        if ( drive != EDriveC )

            {

            MPX_DEBUG2("CMPXHarvesterDatabaseManager::CloseMassStorageDatabases closing DB on drive %d", drive);

        	  db->Close();

#ifdef __RAMDISK_PERF_ENABLE                

            if( iRAMDiskPerfEnabled && db->IsUseRamDrive() )

                {

                MPX_DEBUG1("CMPXHarvesterDatabaseManager::CloseDatabase DB is on RAM");

                db->SetRamDriveInfo( iRAMDrive, EFalse ); 

                TInt err = DoCopyDBFromRam (drive);

                if ( err )

                    {

                    MPX_DEBUG2("CMPXHarvesterDatabaseManager::CloseDatabase DB copy error=%d", err);                

                    RemoveDummyFile( drive );

                    }

                }

#endif

            delete db;

            iDatabases.Remove(i);

            }

        else

            {

            ++i;

            }

        }

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::CloseDatabase

// ---------------------------------------------------------------------------

//

void CMPXHarvesterDatabaseManager::CloseDatabase( TDriveNumber aDrive )

    {

    MPX_DEBUG2("-->CMPXHarvesterDatabaseManager::CloseDatabase drive %d", aDrive );

    TInt index = FindDatabaseIndex( aDrive );

    if ( index != KErrNotFound )

        {

        CMPXHarvesterDB * db =iDatabases[index];

        db->Close();

#ifdef __RAMDISK_PERF_ENABLE                

        if( iRAMDiskPerfEnabled && db->IsUseRamDrive() )

            {

            MPX_DEBUG1("CMPXHarvesterDatabaseManager::CloseDatabase DB is on RAM");

            db->SetRamDriveInfo( iRAMDrive, EFalse ); 

            TInt err = DoCopyDBFromRam(aDrive);

            if ( err )

                {

                MPX_DEBUG2("CMPXHarvesterDatabaseManager::CloseDatabase DB copy error=%d", err);                

                RemoveDummyFile( aDrive );

                }

            }

#endif

        delete db;

        iDatabases.Remove(index);

        }

    MPX_DEBUG1("<--CMPXHarvesterDatabaseManager::CloseDatabase");

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::DropDatabase

// ---------------------------------------------------------------------------

//

void CMPXHarvesterDatabaseManager::DropDatabase( TDriveNumber aDrive )

    {

    MPX_DEBUG2("CMPXHarvesterDatabaseManager::DropDatabase drive %d <---", aDrive );

    TInt index = FindDatabaseIndex( aDrive );

    if ( index != KErrNotFound )

        {

        CMPXHarvesterDB * db =iDatabases[index];

#ifdef __RAMDISK_PERF_ENABLE                

        if( iRAMDiskPerfEnabled && db->IsUseRamDrive() )

            {

            MPX_DEBUG1("CMPXHarvesterDatabaseManager::DropDatabase DB is on RAM");

            db->Close();

            // delete db on ram drive.

            TFileName src = GenerateHarvesterDbName( TDriveUnit(aDrive), ETrue );

            BaflUtils::DeleteFile(iFs, src);

            }

#endif

        delete db;

        iDatabases.Remove(index);

        }

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::DropDatabase --->");

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::FindDatabaseIndex

// ---------------------------------------------------------------------------

//

TInt CMPXHarvesterDatabaseManager::FindDatabaseIndex ( TDriveNumber aDrive )

    {

    TInt count = iDatabases.Count();

    for( TInt i=0; i<count; ++i )

        {

        CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];

        if( db->GetDbDrive() == aDrive )

            {

            MPX_DEBUG3("CMPXHarvesterDatabaseManager::FindDatabaseIndex drive=%d returns index %d ", aDrive, i);

            return i;

            }

        }

    MPX_DEBUG2("CMPXHarvesterDatabaseManager::FindDatabaseIndex drive=%d returns KErrNotFound", aDrive);

    return KErrNotFound;

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::DataaseIsOpen

// ---------------------------------------------------------------------------

//

TBool CMPXHarvesterDatabaseManager::DatabaseIsOpen( TDriveNumber aDrive )

    {

    return FindDatabaseIndex( aDrive ) != KErrNotFound;

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::GetDatabase

// ---------------------------------------------------------------------------

//

CMPXHarvesterDB& CMPXHarvesterDatabaseManager::GetDatabaseL( TDriveNumber aDrive )

    {

    TInt index = FindDatabaseIndex( aDrive );

    User::LeaveIfError (index); // Not found, so we leave

    return *iDatabases[index];

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::Count

// ---------------------------------------------------------------------------

//

TInt CMPXHarvesterDatabaseManager::Count()

    {

    return iDatabases.Count();

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::GetDatabaseL

// ---------------------------------------------------------------------------

//

CMPXHarvesterDB& CMPXHarvesterDatabaseManager::GetDatabaseL( TInt aDb )

    {

    if( aDb > iDatabases.Count() )

        {

        User::Leave(KErrNotFound/*KErrArgument*/);

        }

    return *iDatabases[aDb];

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::RecreateDatabase

// ---------------------------------------------------------------------------

//

void CMPXHarvesterDatabaseManager::RecreateDatabases()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::RecreateDatabases <--");

    for( TInt i=0; i < iDatabases.Count(); )

        {

        // Close db, delete and recreate

        //

        MPX_DEBUG2("RecreateDatabasesL() -- %i", i);

        CMPXHarvesterDB* cur = iDatabases[i];

        cur->Close();

        cur->DeleteDatabase();

        // trap leave just in case 1 db had err

        //

        TRAPD( openError, cur->OpenL() );

        if( openError != KErrNone )

            {

            MPX_DEBUG2("CMPXHarvesterDatabaseManager::RecreateDatabases: opening failed, error=%d", openError);

            iDatabases.Remove(i);

            delete cur;

            }

        else 

            {

            ++i;

            }

        }

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::IsRemoteDrive

// ---------------------------------------------------------------------------

//

TBool CMPXHarvesterDatabaseManager::IsRemoteDrive(TDriveNumber aDrive)

    {

    TDriveInfo driveInfo;

    TBool isRemoteDrive(EFalse);

    if (iFs.Drive(driveInfo, aDrive) == KErrNone)

        {

        isRemoteDrive = driveInfo.iDriveAtt & KDriveAttRemote;

        }

    return isRemoteDrive;

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::IsLocalDrive

// ---------------------------------------------------------------------------

//

TBool CMPXHarvesterDatabaseManager::IsLocalDrive( TDriveNumber aDrive )

    {

    TDriveInfo driveInfo;

    return (iFs.Drive ( driveInfo, aDrive) == KErrNone )

           && driveInfo.iType != EMediaNotPresent 

           && ! (driveInfo.iDriveAtt & KDriveAttRemote);

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::BeginL

// ---------------------------------------------------------------------------

// 

void CMPXHarvesterDatabaseManager::BeginL()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::BeginL <--");

    TInt count( iDatabases.Count() );

    for( TInt i=0; i<count; ++i )

        {

        CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];

        if(!db->InTransaction())

             {

        TRAPD(err, db->BeginL());

        User::LeaveIfError(err);

             }

        }

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::BeginL -->");

    }

// ---------------------------------------------------------------------------

// CMPXHarvesterDatabaseManager::CommitL

// ---------------------------------------------------------------------------

//

void CMPXHarvesterDatabaseManager::CommitL()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::CommitL <--");

    TInt count( iDatabases.Count() );

    for( TInt i=0; i<count; ++i )

        {

        CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];

        // commit only on databases that are in transaction

        if(db->InTransaction())

            {

            TRAPD(err, db->CommitL());

            User::LeaveIfError(err);