/*

* Copyright (c) 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:

*

*/

#include "MemSpyExportBitmapsToMemoryCardDialog.h"

// System includes

#include <eikprogi.h>

#include <AknWaitDialog.h>

#include <AknQueryDialog.h>

#include <coemain.h>

#include <eikenv.h>

#include <avkon.hrh>

#include <memspyui.rsg>

// Engine includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyenginehelperchunk.h>

#include <memspy/engine/memspyenginehelpercodesegment.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyenginehelperstack.h>

#include <memspy/engine/memspyenginehelperthread.h>

#include <memspy/engine/memspyenginehelperprocess.h>

#include <memspy/engine/memspyenginehelperfbserv.h>

// Driver includes

#include <memspy/driver/memspydriverenumerationsshared.h>

// Literal constants

_LIT( KMemSpyBitmapExportFolderAndFileName, "e:\\MemSpy\\Images\\%04d%02d%02d_%02d.%02d.%02d\\");

CMemSpyExportBitmapsToMemoryCardDialog::CMemSpyExportBitmapsToMemoryCardDialog( RFs& aFsSession, const CMemSpyEngineFbServBitmapArray& aBitmaps )

:   CActive(EPriorityIdle), iFsSession(aFsSession), iBitmaps(aBitmaps)

    {

    CActiveScheduler::Add(this);

    }

CMemSpyExportBitmapsToMemoryCardDialog::~CMemSpyExportBitmapsToMemoryCardDialog()

    {

    Cancel();

    //

    delete iProgressDialog;

    //

    iMimeTypeArray.ResetAndDestroy();

    iMimeTypeArray.Close();

    //

    if ( iEncoder )

        {

        iEncoder->Cancel();

        }

    delete iEncoder;

    delete iFolderName;

    delete iBmpMimeType;

    }

void CMemSpyExportBitmapsToMemoryCardDialog::ConstructL()

    {

    // Check card is ready

    if  ( CheckMemoryCardAvailableL( iFsSession ) == EFalse )

        {

        User::Leave( KErrNotReady );

        }

    // Get mime type for BMP file

    IdentifyBmpMimeTypeL();

    // Prepare unique empty folder

    PrepareFolderNameSpecL();

    // Prepare UI stuff

    iProgressDialog = new( ELeave ) CAknProgressDialog( reinterpret_cast< CEikDialog** >( &iProgressDialog ) );

    iProgressDialog->SetCallback( this );

    iProgressDialog->SetGloballyCapturing( ETrue );

    iProgressDialog->PrepareLC( R_MEMSPY_EXPORT_TO_MEMORYCARD_DIALOG );

    //

    iProgressInfo = iProgressDialog->GetProgressInfoL( );

    iProgressInfo->SetFinalValue( iBitmaps.Count() );

    //

    iProgressDialog->MakeVisible( ETrue ); // Visible right away

    //

    iDialogDismissed = EFalse;

    iProgressInfo->SetAndDraw( 0 );

    // Start the process rolling...

    CompleteSelf(KErrNone);

    //

    iProgressDialog->RunLD( );

    }

CMemSpyExportBitmapsToMemoryCardDialog* CMemSpyExportBitmapsToMemoryCardDialog::NewL( RFs& aFsSession, const CMemSpyEngineFbServBitmapArray& aBitmaps )

    {

    CMemSpyExportBitmapsToMemoryCardDialog* self = new(ELeave) CMemSpyExportBitmapsToMemoryCardDialog( aFsSession, aBitmaps );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

void CMemSpyExportBitmapsToMemoryCardDialog::Cancel()

    {

    CActive::Cancel();

    }

TBool CMemSpyExportBitmapsToMemoryCardDialog::CheckMemoryCardAvailableL( RFs& aFsSession )

    {

    TBool available = EFalse;

    //

    TDriveInfo driveInfo;

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

        {

        // Other checks needed?

        available = ETrue;

        }

    //

    return available;

    }

void CMemSpyExportBitmapsToMemoryCardDialog::RunL()

    {

    const TInt error = iStatus.Int();

    User::LeaveIfError( error );

    if  ( !iDialogDismissed )

        {

        // Do we have more items to process?

        if  ( TryToExportSingleBitmapL() )

            {

            _LIT(KTextFormat, "Saving image\n%d/%d");

            TBuf<128> buf;

            buf.Format( KTextFormat, iBitmapIndex, iBitmaps.Count() );

            //

            iProgressDialog->SetTextL( buf );

            iProgressInfo->SetAndDraw( iBitmapIndex );

            iProgressDialog->DrawDeferred();

            }

        else

            {

            // We're done - RunL will not be called again

            if  (iProgressInfo)

                {

                const TInt finalValue = iProgressInfo->Info().iFinalValue;

                iProgressInfo->SetAndDraw( finalValue );

                //

                delete iProgressDialog;

                iProgressDialog = NULL;

                //

                delete this;

                }

            }

        User::ResetInactivityTime();

        }

    else

        {

        delete iProgressDialog;

        iProgressDialog = NULL;

        //

        delete this;

        }

    }

void CMemSpyExportBitmapsToMemoryCardDialog::DoCancel()

    {

    if  ( iEncoder )

        {

        iEncoder->Cancel();

        }

    iDialogDismissed = ETrue;

    }

TInt CMemSpyExportBitmapsToMemoryCardDialog::RunError( TInt /*aError*/ )

    {

    TRAP_IGNORE(

        // Try the next image

        if  ( TryToExportSingleBitmapL() == EFalse )

            {

            iDialogDismissed = ETrue;

            delete this;

            }

    );

    //

    return KErrNone;

    }

void CMemSpyExportBitmapsToMemoryCardDialog::DialogDismissedL( TInt /*aButtonId*/ )

    {

    iDialogDismissed = ETrue;

    iProgressDialog = NULL;

    }

void CMemSpyExportBitmapsToMemoryCardDialog::CompleteSelf( TInt aError )

    {

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, aError );

    SetActive();

    }

void CMemSpyExportBitmapsToMemoryCardDialog::ExportBitmapL( const CMemSpyEngineFbServBitmap& aBitmap )

    {

    // Create a filename

    TFileName fileName( *iFolderName );

    aBitmap.GetExportableFileNameL( fileName );

    // Create encoder object...

    CImageEncoder* encoder = CImageEncoder::FileNewL( iFsSession, fileName, *iBmpMimeType );

    delete iEncoder;

    iEncoder = encoder;

    // Start operation

    iEncoder->Convert( &iStatus, aBitmap.Bitmap() );

    SetActive();

    }

void CMemSpyExportBitmapsToMemoryCardDialog::IdentifyBmpMimeTypeL()

    {

    _LIT(KBmpExtension, ".bmp");

    CImageEncoder::GetFileTypesL( iMimeTypeArray );

    //

    const TInt count = iMimeTypeArray.Count();

    //

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

        {

        CFileExtensionMIMEType* extension = iMimeTypeArray[ i ];

        if  ( extension->FileExtension().FindF( KBmpExtension ) >= 0 )

            {

            // Found it - save mime type info

            iBmpMimeType = extension->MIMEType().AllocL();

            iMimeTypeArray.ResetAndDestroy();

            iMimeTypeArray.Close();

            return;

            }

        }

    //

    User::Leave( KErrNotFound );    

    }

void CMemSpyExportBitmapsToMemoryCardDialog::PrepareFolderNameSpecL()

    {

    delete iFolderName;

    iFolderName = NULL;

    // Make a unique filename format specifier.

    TTime now;

    now.HomeTime();

    const TDateTime dt( now.DateTime() );

    // Build it up...

    iFolderName = HBufC::NewL( KMaxFileName );

    TPtr pName( iFolderName->Des() );

    pName.Format( KMemSpyBitmapExportFolderAndFileName, dt.Year(), dt.Month()+1, dt.Day()+1, dt.Hour(), dt.Minute(), dt.Second());

    // Create directory

    const TInt error = iFsSession.MkDirAll( pName );

    User::LeaveIfError( error );

    }

TBool CMemSpyExportBitmapsToMemoryCardDialog::TryToExportSingleBitmapL()

    {

    TBool startedExport = EFalse;

    const TInt count = iBitmaps.Count();

    for( ; ( iBitmapIndex < count ) && ( startedExport == EFalse ); iBitmapIndex++ )

        {

        const CMemSpyEngineFbServBitmap& memSpyBitmap = iBitmaps.At( iBitmapIndex );

        const CFbsBitmap& fbsBitmap = memSpyBitmap.Bitmap();

        const TSize size( fbsBitmap.SizeInPixels() );

        // We don't want to export bitmaps which have a zero-pixel dimension.

        if  ( size.iHeight > 0 && size.iWidth > 0 )

            {

            // This completes the object's request status and will therefore

            // result in a further call to RunL() when the export to BMP

            // is completed.

            ExportBitmapL( memSpyBitmap );

            // And indicate we managed to start an operation...

            startedExport = ETrue;

            }

        }

    //

    return startedExport;

    }