/*

* Copyright (c) 2006-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:  Main class in the Memory manager component

*

*/

#include <e32std.h>

#include <e32base.h>

#include <MCLFContentListingEngine.h>

#include <ContentListingFactory.h>

#include <mpxharvesterutility.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionhelper.h>

#include <pathinfo.h>

#include "cmdmmain.h"

#include "msdebug.h"

#include "cmmmmain.h"

#include "cmdriveinfo.h"

#include "cmmmquotalistener.h"

#include "cmmmshrinker.h"

#include "cmmmobserver.h"

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

// CCmMmMain::NewL

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

//

EXPORT_C CCmMmMain* CCmMmMain::NewL( CCmDmMain& aDbManager )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::NewL() start"));

    CCmMmMain* self = CCmMmMain::NewLC( aDbManager );

    CleanupStack::Pop( self );

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::NewL() end"));

    return self;

    }

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

// CCmMmMain::NewLC

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

//

EXPORT_C CCmMmMain* CCmMmMain::NewLC( CCmDmMain& aDbManager )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::NewLC() start"));

    CCmMmMain* self = new ( ELeave ) CCmMmMain( aDbManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::NewLC() end"));

    return self;

    }

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

// C++ destructor

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

//

EXPORT_C CCmMmMain::~CCmMmMain()

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::~CCmMmMain() start"));

    iFileSession.Close();

    iQuotaListeners.ResetAndDestroy();

    delete iDeleter;

    delete iFilesToDelete;

    delete iFilesToShrink;

    if( iHarvester )

        {

        iHarvester->Close();

        }

    CloseMpxCollectionHelper();

    delete iObserver;

    delete iShrinker;

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::~CCmMmMain() end"));

    }

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

// CCmMmMain::Cancel

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

//

EXPORT_C void CCmMmMain::Cancel()

    {

    if ( iDeleter )

        {

        iDeleter->Cancel();

        if ( iObserver )

            {

            // Trap here, do nothing if it leaves.

            TRAP_IGNORE( iObserver->DeleteCompleteL( KErrCancel ) );

            }

        }

    if ( iShrinker )

        {

        iShrinker->Cancel();

        if ( iObserver )

            {

            // Trap here, do nothing if it leaves

            TRAP_IGNORE( iObserver->ShrinkCompleteL( KErrCancel ) );

            }

        }

    for( TInt i = 0; i < iQuotaListeners.Count(); i++ )

        {        

        iQuotaListeners[i]->Cancel();

        }

    }

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

// CCmMmMain::DeleteFilesL

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

//

EXPORT_C void CCmMmMain::DeleteFilesL( CDesCArray& aFiles )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::DeleteFilesL() start"));

    if ( &aFiles && aFiles.Count() > 0 )

        {

        delete iFilesToDelete;

        iFilesToDelete = NULL;

        iFilesToDelete = new ( ELeave ) CDesC16ArrayFlat( aFiles.Count() );

        for ( TInt i = 0; i < aFiles.Count(); i++ )

            {

            iFilesToDelete->AppendL( aFiles[i] );

            }

        }

    iDeleteIndex = 0;

    if ( iDeleter )

        {

        CloseMpxCollectionHelper();

        iMpxCollectionHelper = CMPXCollectionHelperFactory::NewCollectionHelperL();

        iDeleter->Start( TCallBack( BackgroundDeleteL, this ) );

        }

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::DeleteFilesL() end"));

    }

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

// CCmMmMain::SetObserver

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

//

EXPORT_C void CCmMmMain::SetObserver( MCmMmObserver& aObserver )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::SetObserver() start"));

    iObserver = &aObserver;

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::SetObserver() end"));

    }

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

// CCmMmMain::SetQuotaListenerStateL

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

//

EXPORT_C void CCmMmMain::SetQuotaListenerStateL( TBool aState )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::SetQuotaListenerStateL() start"));

    if( !aState )

        {

        iQuotaListeners.ResetAndDestroy();

        iQuotaListeners.Close();

        LOG(_L("[MEMORY MNGR]\t Quotalisteners deleted"));

        }

    else

        {

        iDbManager.PrepareQueryCmdL( EDrivesQuery );

        RPointerArray<CCmDriveInfo> drives;

        TRAP_IGNORE( iDbManager.QueryDrivesL( drives ) );

        iQuotaListeners.ResetAndDestroy();

        for( TInt i = 0 ; i < drives.Count(); i++ )

            {

            TRACE(Print(_L("[MEMORY MNGR]\t Starting quota listener to \

            drive = %d"), drives[i]->DriveNumber() ));            

            CCmMmQuotaListener* listener = 

                CCmMmQuotaListener::NewL( 

                    iDbManager, 

                    drives[i]->DriveNumber() );

            }

        drives.ResetAndDestroy();            

        }        

    }

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

// CCmMmMain::ShrinkImagesL

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

//

EXPORT_C void CCmMmMain::ShrinkImagesL( CDesCArray& aFiles )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::ShrinkImagesL() start"));

    if ( !iShrinker )

        {

        iShrinker = CCmMmShrinker::NewL( iDbManager );       

        }

    else

        {

        // Cancel the possible ongoing operation

        iShrinker->Cancel();

        }

    iShrinker->SetObserver( iObserver );

    iShrinker->ShrinkImagesL( aFiles );

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::ShrinkImagesL() end"));

    }

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

// CCmMmMain::MmcState

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

//

TBool CCmMmMain::DriveState( const RFs& aFileServer, TInt aDriveNumber )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::DriveState() start"));

    TDriveInfo driveInfo;

    TInt error = aFileServer.Drive( driveInfo, aDriveNumber );

    //check if MMC is present

    TBool status = EFalse;

    if ( error == KErrNone && driveInfo.iType == EMediaHardDisk )

        {

        status = ETrue;

        LOG(_L("[MEMORY MNGR]\t CCmMmMain::DriveState() Drive found"));

        }

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::DriveState() end"));

    return status;

    }

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

// C++ constructor

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

//

CCmMmMain::CCmMmMain( CCmDmMain& aDbManager ) :

    iDeleteIndex( 0 ),

    iQuotaListenerState( ETrue ),

    iDbManager( aDbManager )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::CCmMmMain() start"));

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::CCmMmMain() end"));

    }

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

// CCmMmMain::ConstructL

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

//

void CCmMmMain::ConstructL()

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::ConstructL() start"));

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

    iDeleter = CIdle::NewL( CActive::EPriorityIdle );    

    iHarvester = CMPXHarvesterFactory::NewL();

    SetQuotaListenerStateL( ETrue );

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::ConstructL() end"));

    }

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

// CCmMmMain::BackgroundDeleteL

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

//

TInt CCmMmMain::BackgroundDeleteL( TAny* aMm )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::BackgroundDeleteL() start"));

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::BackgroundDeleteL() end"));

    return ((CCmMmMain*)aMm)->DoBackgroundDeleteL();

    }

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

// CCmMmMain::DoBackgroundDeleteL

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

//

TInt CCmMmMain::DoBackgroundDeleteL()

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::DoBackgroundDeleteL() start"));

    TInt moreFiles = EFalse;

    TInt error = KErrNone;

    TInt trapinfo( KErrNone );

    if ( iFilesToDelete )

        {

        if ( iDeleteIndex < iFilesToDelete->Count() )

            {

            TPtrC filenameTemp = (*iFilesToDelete)[iDeleteIndex];

            // Delete file from filesystem

            error = iFileSession.Delete( filenameTemp );

            TRACE(Print(_L("[MEMORY MNGR]\t CCmMmMain:DoBackgroundDeleteL \

error: %d"), error));

#ifdef _DEBUG

            TRACE(Print(_L("[MEMORY MNGR]\t CCmMmMain: File %S deleted"),

                                          &filenameTemp ));

#endif // _DEBUG

            TRAP( trapinfo, iMpxCollectionHelper->RemoveL( filenameTemp ) );

            TRACE(Print(_L("[MEMORY MNGR]\t CCmMmMain:DoBackgroundDeleteL \

RemoveL: %d"), trapinfo));

            iDeleteIndex++;

            }

        // return ETrue if there are more files to delete

        if ( iDeleteIndex < iFilesToDelete->Count() )

            {

            moreFiles = ETrue;

            }

        // No more files to be deleted. Call Media Gallery update.

        else if ( iFilesToDelete->Count() )

            {

            MCLFContentListingEngine* clfEngine =

                    ContentListingFactory::NewContentListingEngineLC();

            if( clfEngine )

                {

                TRAP_IGNORE( clfEngine->UpdateItemsL() );

                TRAP_IGNORE( iHarvester->RemoveFilesL( *iFilesToDelete ) );

                }

            CleanupStack::PopAndDestroy();

            }

        }

    // If all files are deleted, inform observer that deletion is ready.

    if ( !moreFiles )

        {

        CloseMpxCollectionHelper();

        }

    if ( !moreFiles && iObserver )

        {

        delete iFilesToDelete;

        iFilesToDelete = NULL;

        iObserver->DeleteCompleteL( error );

        }

    LOG(_L("[MEMORY MNGR]\t CCmMmMain::DoBackgroundDeleteL() end"));

    // Return EFalse if background deletion is done, ETrue if there are more 

    // files to be deleted.

    return moreFiles;

    }

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

// CCmMmMain::CloseMpxCollectionHelper

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

//    

void CCmMmMain::CloseMpxCollectionHelper()

    {

    if( iMpxCollectionHelper )

        {

    	iMpxCollectionHelper->Close();

        }

    iMpxCollectionHelper = NULL;

    }

// End of file