/*

* Copyright (c) 2008-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:   Thumbnail save task implementation

*

*/

/**

 * @internal reviewed 31/07/2007 by Simon Brooks

 */

// INCLUDE FILES

#include "glxtnsavethumbnailtask.h"

#include <glxassert.h>

#include <glxtracer.h>

#include <glxthumbnail.h>

#include <imageconversion.h>

#include <s32mem.h>

#include "glxtnfileinfo.h"

#include "mglxtnstorage.h"

// Minimum size of thumbnail to be saved as JPEG rather than bitmap

const TInt KGlxMinPixelsForJpeg = 30000;

const TInt KGlxBitmapBufferGranularity = 1024;

// ============================ MEMBER FUNCTIONS ===============================

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

// CGlxtnSaveThumbnailTask::CGlxtnSaveThumbnailTask

// C++ default constructor can NOT contain any code, that might leave.

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

//

CGlxtnSaveThumbnailTask::CGlxtnSaveThumbnailTask(const TGlxMediaId& aItemId,

                    const TSize& aSize, MGlxtnThumbnailStorage* aStorage) :

    CGlxtnTask(KGlxtnTaskIdSaveThumbnail, aItemId, aStorage), iSize(aSize)

    {

    TRACER("CGlxtnSaveThumbnailTask::CGlxtnSaveThumbnailTask()");

    GLX_ASSERT_ALWAYS( aStorage, Panic( EGlxPanicIllegalArgument ),

                        "CGlxtnSaveThumbnailTask created without storage" );

    // Save task is always low priority

    SetPriority(EPriorityLow);

    }

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

// CGlxtnSaveThumbnailTask::CGlxtnSaveThumbnailTask

// Constructor for derived classes.

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

//

CGlxtnSaveThumbnailTask::CGlxtnSaveThumbnailTask(const TGlxtnTaskId& aId,

                const TGlxMediaId& aItemId, MGlxtnThumbnailStorage* aStorage) :

    CGlxtnTask(aId, aItemId, aStorage)

    {

    TRACER("CGlxtnSaveThumbnailTask::CGlxtnSaveThumbnailTask()");

    GLX_ASSERT_ALWAYS( aStorage, Panic( EGlxPanicIllegalArgument ),

                        "CGlxtnSaveThumbnailTask created without storage" );

    }

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

// CGlxtnSaveThumbnailTask::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CGlxtnSaveThumbnailTask::ConstructL(CGlxtnFileInfo* aFileInfo,

                                            CFbsBitmap* aThumbnail)

    {

    TRACER("void CGlxtnSaveThumbnailTask::ConstructL()");

    // Shouldn't create save task if client doesn't use storage

    if ( !(Storage() && aFileInfo && aThumbnail) )

        {

        User::Leave(KErrArgument);

        }

    // Must not leave after taking ownership of these

    iFileInfo = aFileInfo;

    iThumbnail = aThumbnail;

    }

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

// CGlxtnSaveThumbnailTask::NewL

// Two-phased constructor.

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

//

CGlxtnSaveThumbnailTask* CGlxtnSaveThumbnailTask::NewL(

                    const TGlxMediaId& aItemId,

                    CGlxtnFileInfo* aFileInfo, const TSize& aSize,

                    CFbsBitmap* aThumbnail, MGlxtnThumbnailStorage* aStorage)

    {

    TRACER("CGlxtnSaveThumbnailTask* CGlxtnSaveThumbnailTask::NewL()");

    CGlxtnSaveThumbnailTask* self = new (ELeave) CGlxtnSaveThumbnailTask(

                                                    aItemId, aSize, aStorage);

    CleanupStack::PushL(self);

    self->ConstructL(aFileInfo, aThumbnail);

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CGlxtnSaveThumbnailTask::~CGlxtnSaveThumbnailTask()

    {

    TRACER("Destructor CGlxtnSaveThumbnailTask::~CGlxtnSaveThumbnailTask()");

    delete iEncoder;

    delete iThumbnail;

    delete iData;

    delete iFileInfo;

    }

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

// DoStartL

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

//

TBool CGlxtnSaveThumbnailTask::DoStartL(TRequestStatus& aStatus)

    {

    TRACER("CGlxtnSaveThumbnailTask::DoStartL()");

    EncodeThumbnailL(aStatus);

    return ETrue;

    }

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

// DoCancel

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

//

void CGlxtnSaveThumbnailTask::DoCancel()

    {

    TRACER("CGlxtnSaveThumbnailTask::DoCancel()");

    if ( iEncoder )

        {

        iEncoder->Cancel();

        }

    Storage()->StorageCancel();

    }

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

// DoRunL

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

//

TBool CGlxtnSaveThumbnailTask::DoRunL(TRequestStatus& aStatus)

    {

    TRACER("TBool CGlxtnSaveThumbnailTask::DoRunL()");

    if ( KErrNone == aStatus.Int() && EStateEncoding == iState )

        {

        SaveThumbnailL(aStatus);

        return ETrue;

        }

    return EFalse;  // Task is complete

    }

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

// DoRunError

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

//

TBool CGlxtnSaveThumbnailTask::DoRunError(TInt /*aError*/)

    {

    TRACER("CGlxtnSaveThumbnailTask::DoRunError()");

    delete iEncoder;

    iEncoder = NULL;

    return EFalse;  // Task is complete

    }

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

// EncodeThumbnailL

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

//

void CGlxtnSaveThumbnailTask::EncodeThumbnailL(TRequestStatus& aStatus)

    {

    TRACER("CGlxtnSaveThumbnailTask::EncodeThumbnailL()");

    TSize size(iThumbnail->SizeInPixels());

    User::LeaveIfError(iThumbnail->SetDisplayMode(KGlxThumbnailDisplayMode));

    delete iData;

    iData = NULL;

    if ( KGlxMinPixelsForJpeg <= size.iWidth * size.iHeight )

        {

        // Encode as JPEG

        iFormat = EGlxIDF_JPEG;

        delete iEncoder;

        iEncoder = NULL;

        iEncoder = CImageEncoder::DataNewL(iData, CImageEncoder::EOptionNone,

                                            KImageTypeJPGUid);

        iState = EStateEncoding;

        iEncoder->Convert(&aStatus, *iThumbnail);

        }

    else

        {

        // Externalise bitmap into buffer

        iFormat = EGlxIDF_Bitmap;

        CBufBase* buffer = CBufSeg::NewL(KGlxBitmapBufferGranularity);

        CleanupStack::PushL(buffer);

        RBufWriteStream stream(*buffer);

        CleanupClosePushL(stream);

        stream << *iThumbnail;

        stream.CommitL();

        CleanupStack::PopAndDestroy(&stream);

        TInt length = buffer->Size();

        iData = HBufC8::NewL(length);

        TPtr8 ptr(iData->Des());

        buffer->Read(0, ptr, length);

        CleanupStack::PopAndDestroy(buffer);

        SaveThumbnailL(aStatus);

        }

    }

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

// SaveThumbnailL

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

//

void CGlxtnSaveThumbnailTask::SaveThumbnailL(TRequestStatus& aStatus)

    {

    TRACER("CGlxtnSaveThumbnailTask::SaveThumbnailL()");

    delete iEncoder;

    iEncoder = NULL;

    iState = EStateSaving;

    Storage()->SaveThumbnailDataL(*iData, iFormat, ItemId(),

                                    *iFileInfo, iSize, &aStatus);

    }

//  End of File