/*
* Copyright (c) 2005-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: 
*       Provides methods for CPbk2ImageManager implementation classes
*
*/


// INCLUDE FILES

#include "CPbk2ImageWriterBase.h"

// From Phonebook2
#include "CPbk2ImageReader.h"
#include "MPbk2ImageOperationObservers.h"
#include "CPbk2ImageData.h"

// From System
#include <imageconversion.h>
#include <bitmaptransforms.h>

/// Unnamed namespace for local defintions
namespace {

// LOCAL CONSTANTS

/// JPEG file mime type
_LIT8(KJpegMimeType, "image/jpeg");

// States for CPbk2ImageWriterBase
enum TWriterState
    {
    EStateInitialize = 0,
    EStateCheckFormatAndSize,
    EStateScaleBitmap,
    EStateCreateImage,
    EStateConvertToJpeg,
    EStateStoreImage,
    EStateComplete,
    EStateEnd
    };

#ifdef _DEBUG
enum TPanicCode
    {
    EPanicPreCond_ConstructL,
    EPanicPreCond_CheckFormatAndSizeL,
    EPanicPreCond_ScaleBitmapL,
    EPanicPreCond_CreateImageL,
    EPanicPreCond_ConvertToJpegL,
    EPanicPreCond_StoreImageL,
    EPanicPreCond_DoCancel
    };
#endif // _DEBUG


// ==================== LOCAL FUNCTIONS ====================

/**
 * Comparison operator for TSize objects. Compares width and height members.
 *
 * @param aLhs Reference to left hand side TSize
 * @param aRhs Reference to right hand side TSize
 * @return ETrue if lhs's width and height are less or equal to rhs's
 *         width and height. Otherwise returns EFalse.
 */
 inline TBool operator<=(const TSize& aLhs, const TSize& aRhs)
    {
    return (aLhs.iWidth<=aRhs.iWidth && aLhs.iHeight<=aRhs.iHeight);
    }

#ifdef _DEBUG
void Panic(TPanicCode aReason)
    {
    _LIT(KPanicText, "CPbk2ImageWriterBase");
    User::Panic(KPanicText,aReason);
    }
#endif // _DEBUG
}  // namespace


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

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::CPbk2ImageWriterBase
// --------------------------------------------------------------------------
//
CPbk2ImageWriterBase::CPbk2ImageWriterBase
        (MPbk2ImageSetObserver& aObserver) :
    CActive(CActive::EPriorityStandard),
    iObserver(aObserver)
    {
    CActiveScheduler::Add(this);
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::~CPbk2ImageWriterBase
// --------------------------------------------------------------------------
//
CPbk2ImageWriterBase::~CPbk2ImageWriterBase()
    {
    Cancel();
    delete iImageEncoder;
    delete iBitmapScaler;
    delete iBitmap;
    delete iImageData;
    delete iImageReader;
    }
    
// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::ConstructL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::ConstructL()
    {
    __ASSERT_DEBUG(!iImageReader, Panic(EPanicPreCond_ConstructL));
    iImageReader = CPbk2ImageReader::NewL(*this);
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::StartWriteL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::StartWriteL(const CFbsBitmap& aBitmap)
    {
    CancelWrite();
    iBitmap = new(ELeave) CFbsBitmap;
    User::LeaveIfError(iBitmap->Duplicate(aBitmap.Handle()));
    ScaleBitmapL();
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::StartWriteL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::StartWriteL(const TDesC8& aBuffer)
    {
    CancelWrite();

    if (iImageData)
    	{
        delete iImageData;
        iImageData = NULL;
    	}
    iImageData = CPbk2ImageBufferData::NewL(aBuffer);

    iImageReader->RecognizeFormatFromBufferL(aBuffer);

    TPbk2ImageManagerParams readerParams;
    SetupReaderParams(readerParams);
    iImageReader->ReadFromBufferL(aBuffer,&readerParams);
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::StartWriteL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::StartWriteL(const TDesC& aFileName)
    {
    CancelWrite();

    if (iImageData)
    	{
        delete iImageData;
        iImageData = NULL;
    	}
    iImageData = CPbk2ImageFileData::NewL(aFileName);

    iImageReader->RecognizeFormatFromFileL(aFileName);

    TPbk2ImageManagerParams readerParams;
    SetupReaderParams(readerParams);
    iImageReader->ReadFromFileL(aFileName, &readerParams);
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::CancelWrite
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::CancelWrite()
    {
    Cancel();
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::ImageReadComplete
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::ImageReadComplete
        (CPbk2ImageReader& /*aReader*/, CFbsBitmap* aBitmap)
    {
    delete iBitmap;
    iBitmap = aBitmap;
    NextState();
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::ImageReadFailed
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::ImageReadFailed
        (CPbk2ImageReader& /*aReader*/, TInt aError)
    {
    CancelWrite();
    iObserver.Pbk2ImageSetFailed(*this,aError);
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::ImageOpenComplete
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::ImageOpenComplete(CPbk2ImageReader& /*aReader*/)
    {
    NextState();
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::NextState
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::NextState()
    {
    ++iState;
    TRAPD(err, ExecuteStateL());
    if (err)
        {
        CancelWrite();
        iObserver.Pbk2ImageSetFailed(*this,err);
        }
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::ExecuteStateL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::ExecuteStateL()
    {
    switch (iState)
        {
        case EStateCheckFormatAndSize:
            {
            CheckFormatAndSizeL();
            break;
            }
        case EStateScaleBitmap:
            {
            ScaleBitmapL();
            break;
            }
        case EStateCreateImage:
            {
            CreateImageL();
            break;
            }
        case EStateConvertToJpeg:
            {
            ConvertToJpegL();
            break;
            }
        case EStateStoreImage:
            {
            StoreImageL();
            break;
            }
        case EStateComplete:
            {
            Complete();
            break;
            }
        default:
            {
            // Media server objects might sometimes complete although they have
            // been canceled. Catch those cases here.
            CancelWrite();
            break;
            }
        }
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::CheckFormatAndSizeL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::CheckFormatAndSizeL()
    {
    __ASSERT_DEBUG(iImageReader, Panic(EPanicPreCond_CheckFormatAndSizeL));
    iState = EStateCheckFormatAndSize;
    TFrameInfo frameInfo;
    iImageReader->FrameInfo(0,frameInfo);
    if (frameInfo.iOverallSizeInPixels <= ImageSize() &&
        iImageReader->MimeString() == KJpegMimeType)
        {
        // Image resolution is <= personal image size and it is in JPEG
        // format -> store the image directly skipping scaling and
        // conversion.
        iImageReader->Cancel();
        StoreImageL();
        }
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::ScaleBitmapL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::ScaleBitmapL()
    {
    __ASSERT_DEBUG(iBitmap, Panic(EPanicPreCond_ScaleBitmapL));
    iState = EStateScaleBitmap;
    if (iBitmap->SizeInPixels() <= ImageSize())
        {
        // Bitmap size is <= personal image size -> skip scaling
        CreateImageL();
        }
    else
        {
        if (!iBitmapScaler)
            {
            iBitmapScaler = CBitmapScaler::NewL();
            }
        iBitmapScaler->Scale(&iStatus, *iBitmap, ImageSize());
        SetActive();
        }
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::CreateImageL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::CreateImageL()
    {
    __ASSERT_DEBUG(
        iBitmap && iBitmap->SizeInPixels()<=ImageSize() && !iImageEncoder,
        Panic(EPanicPreCond_CreateImageL));
    iState = EStateCreateImage;
    iImageEncoder = CreateImageWriterL();
    TRequestStatus* status = &iStatus;
    User::RequestComplete(status, KErrNone);
    SetActive();
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::ConvertToJpegL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::ConvertToJpegL()
    {
    __ASSERT_DEBUG(
        iBitmap && iBitmap->SizeInPixels()<=ImageSize() && iImageEncoder,
        Panic(EPanicPreCond_ConvertToJpegL));
    
    iImageEncoder->Convert(&iStatus, *iBitmap);
    SetActive();
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::StoreImageL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::StoreImageL()
    {
    iState = EStateStoreImage;
    if (iImageEncoder)
        {
        // Store converted image        
        StoreImageL(*iImageEncoder);
        }
    else
        {
        // Store input image directly
        __ASSERT_DEBUG(iImageData, Panic(EPanicPreCond_StoreImageL));        
        StoreImageL(*iImageData);
        }
    // this causes moving to next state asynchronously
    TRequestStatus* status = &iStatus;
    User::RequestComplete(status, KErrNone);
    SetActive();
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::Complete
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::Complete()
    {
    // End state machine
    iState = EStateEnd;
    // Notify observer
    iObserver.Pbk2ImageSetComplete(*this);
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::SetupReaderParams
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::SetupReaderParams(TPbk2ImageManagerParams& aParams)
    {
    aParams.iSize = ImageSize();
    aParams.iFlags = 
        TPbk2ImageManagerParams::EScaleImage | 
        TPbk2ImageManagerParams::EUseFastScaling;
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::RunL
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::RunL()
    {
    TInt status = iStatus.Int();
    if (status == KErrNone)
        {
        NextState();
        }
    else
        {
        iObserver.Pbk2ImageSetFailed(*this, status);
        }
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::RunError
// --------------------------------------------------------------------------
//
TInt CPbk2ImageWriterBase::RunError(TInt aError)
    {
    iObserver.Pbk2ImageSetFailed(*this, aError);
    return KErrNone;
    }

// --------------------------------------------------------------------------
// CPbk2ImageWriterBase::DoCancel
// --------------------------------------------------------------------------
//
void CPbk2ImageWriterBase::DoCancel()
    {
    __ASSERT_DEBUG(iImageReader, Panic(EPanicPreCond_DoCancel));
    // Cancel own operations
    iState = EStateInitialize;
    if (iImageEncoder)
        {
        iImageEncoder->Cancel();
        delete iImageEncoder;
        iImageEncoder = NULL;
        }
    if (iBitmapScaler) 
        {
        iBitmapScaler->Cancel();
        }

    iImageReader->Cancel();
    delete iImageData;
    iImageData = NULL;
    delete iBitmap;
    iBitmap = NULL;
    }

//  End of File