/*
* Copyright (c) 2002 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: 
*       Methods for Phonebook contact item field embedded thumbnail reader.
*
*/


// INCLUDE FILES

#include "CPbkEmbeddedThumbnail.h"
#include "CPbkImageReader.h"
#include "MPbkThumbnailOperationObservers.h"
#include "PbkImageData.h"
#include <CPbkFFSCheck.h>

#include <e32std.h>
#include <eikappui.h>
#include <TPbkContactItemField.h>
#include <imageconversion.h>

/// Unnamed namespace for local definitions
namespace {

#ifdef _DEBUG
enum TPanicCode
    {
    EPanicReadPreCond_Constructor = 1,
    EPanicReadPreCond_StartReadL,

    EPanicWritePreCond_Constructor = 100,
    EPanicWritePreCond_CreateImageWriterL,
    EPanicWritePreCond_StoreImageL_CMdaImageDataWriteUtility
    };
#endif


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

#ifdef _DEBUG
void Panic(TPanicCode aPanicCode)
    {
    _LIT(KPanicText, "CPbkEmbeddedThumbnail");
    User::Panic(KPanicText, aPanicCode);
    }
#endif

// When thumbnail image is saved to contactdatabase then during saving
// some extra disk space is consumed besides raw thumbnail data.
// Following const is approximation for this needed extra space.
const TInt KHdOverhead = 1024;

// Gives approximation for saved thumbnail size on the disk
inline TInt ThumbnailSizeOnDisk(TInt aBytes)
    {
    return aBytes+KHdOverhead;
    }

}  // namespace


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

/////////////////////////////////////////////////////////////////
// CPbkEmbeddedThumbnailReader 

inline CPbkEmbeddedThumbnailReader::CPbkEmbeddedThumbnailReader
        (const TPbkContactItemField& aField, 
        MPbkThumbnailGetObserver& aObserver) :
    CPbkThumbnailReaderBase(aObserver),
    iField(aField)
    {
    __ASSERT_DEBUG(iField.StorageType()==KStorageTypeStore, 
        Panic(EPanicReadPreCond_Constructor));
    }

inline void CPbkEmbeddedThumbnailReader::ConstructL()
    {
    CPbkThumbnailReaderBase::ConstructL();    
    }

CPbkEmbeddedThumbnailReader* CPbkEmbeddedThumbnailReader::NewLC
        (const TPbkContactItemField& aField,
        MPbkThumbnailGetObserver& aObserver)
    {
    CPbkEmbeddedThumbnailReader* self = 
        new(ELeave) CPbkEmbeddedThumbnailReader(aField,aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

CPbkEmbeddedThumbnailReader::~CPbkEmbeddedThumbnailReader()
    {
    }

void CPbkEmbeddedThumbnailReader::StartReadL(const TPbkImageLoadParameters* aParameters)
    {
    HBufC8* imageBuf = iField.ContactItemField().StoreStorage()->Thing();
    __ASSERT_DEBUG(imageBuf && imageBuf->Length()>0, 
        Panic(EPanicReadPreCond_StartReadL));
    CancelRead();
	if (imageBuf)
		{
		ImageReader().ReadFromBufferL(*imageBuf, aParameters);
		}
    }

/////////////////////////////////////////////////////////////////
// CPbkEmbeddedThumbnailImageReader
inline CPbkEmbeddedThumbnailImageReader::CPbkEmbeddedThumbnailImageReader
        (const TPbkContactItemField& aField, 
        MPbkThumbnailGetImageObserver& aObserver) :
    CPbkThumbnailImageReaderBase(aObserver),
    iField(aField)
    {
    __ASSERT_DEBUG(iField.StorageType()==KStorageTypeStore && !iField.IsEmpty(),
        Panic(EPanicReadPreCond_Constructor));
    }

CPbkEmbeddedThumbnailImageReader* CPbkEmbeddedThumbnailImageReader::NewLC
        (const TPbkContactItemField& aField, 
        MPbkThumbnailGetImageObserver& aObserver)
    {
    CPbkEmbeddedThumbnailImageReader* self = 
        new(ELeave) CPbkEmbeddedThumbnailImageReader(aField,aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

void CPbkEmbeddedThumbnailImageReader::ConstructL()
    {
    CPbkThumbnailImageReaderBase::ConstructL();
    }

CPbkEmbeddedThumbnailImageReader::~CPbkEmbeddedThumbnailImageReader()
    {
    }

void CPbkEmbeddedThumbnailImageReader::DoStartReadL(const TPbkImageLoadParameters* aParameters)
    {
    const TDesC8& imageBuffer = ImageBuffer();
    ImageReader().RecognizeFormatFromBufferL(imageBuffer);
    ImageReader().ReadFromBufferL(imageBuffer, aParameters);
    }

MPbkImageData* CPbkEmbeddedThumbnailImageReader::CreateImageDataLC()
    {
    CPbkImageBufferData* imageData = CPbkImageBufferData::NewL(ImageBuffer());
    CleanupStack::PushL(imageData);
    return imageData;
    }

const TDesC8& CPbkEmbeddedThumbnailImageReader::ImageBuffer() const
    {
    return *(iField.ContactItemField().StoreStorage()->Thing());
    }


/////////////////////////////////////////////////////////////////
// CPbkEmbeddedThumbnailWriter

inline CPbkEmbeddedThumbnailWriter::CPbkEmbeddedThumbnailWriter
        (TPbkContactItemField& aField, 
        MPbkThumbnailSetObserver& aObserver) :
    CPbkThumbnailWriterBase(aObserver), iField(aField)   
    {
    __ASSERT_DEBUG(iField.StorageType()==KStorageTypeStore, 
        Panic(EPanicWritePreCond_Constructor));
    }

inline void CPbkEmbeddedThumbnailWriter::ConstructL()
    {
    CPbkThumbnailWriterBase::ConstructL();
    iFFSCheck=CPbkFFSCheck::NewL();
    }

CPbkEmbeddedThumbnailWriter* CPbkEmbeddedThumbnailWriter::NewLC
        (TPbkContactItemField& aField, 
        MPbkThumbnailSetObserver& aObserver)
    {
    CPbkEmbeddedThumbnailWriter* self = 
        new(ELeave) CPbkEmbeddedThumbnailWriter(aField, aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

CPbkEmbeddedThumbnailWriter::~CPbkEmbeddedThumbnailWriter()
    {
    delete iBitmapBlob;
    delete iFFSCheck;
    }

CImageEncoder* CPbkEmbeddedThumbnailWriter::CreateImageWriterL()
    {
    __ASSERT_DEBUG(!iBitmapBlob, Panic(EPanicWritePreCond_CreateImageWriterL));

    return CImageEncoder::DataNewL
        (iBitmapBlob, CImageEncoder::EOptionNone, KImageTypeJPGUid);
    }

void CPbkEmbeddedThumbnailWriter::StoreImageL(const MPbkImageData& aImageData)
    {
    const TDesC8& imageBuffer = aImageData.GetBufferL();
    if(iFFSCheck->FFSClCheckL(ThumbnailSizeOnDisk(imageBuffer.Length())))
        {
        iField.ContactItemField().StoreStorage()->SetThingL(imageBuffer);
        }    
    }

void CPbkEmbeddedThumbnailWriter::StoreImageL
        (CImageEncoder& /*aImageWriter*/)
    {
    __ASSERT_DEBUG(iBitmapBlob, 
        Panic(EPanicWritePreCond_StoreImageL_CMdaImageDataWriteUtility));
    if(iFFSCheck->FFSClCheckL(ThumbnailSizeOnDisk(iBitmapBlob->Length())))
        {
        iField.ContactItemField().StoreStorage()->SetThingL(*iBitmapBlob);        
        }
    }

void CPbkEmbeddedThumbnailWriter::DoCancel()
    {
    delete iBitmapBlob;
    iBitmapBlob = NULL;

    // Let base class do its own canceling
    CPbkThumbnailWriterBase::DoCancel();
    }

TSize CPbkEmbeddedThumbnailWriter::ImageSize() const
    {
    if (EPbkFieldIdCodImageID==iField.PbkFieldId())
        {
        return (static_cast<CEikAppUi*>(CCoeEnv::Static()->AppUi()))->
            ApplicationRect().Size();
        }
    else 
        {
        //Default: EPbkFieldIdThumbnailImage
        return KPbkPersonalImageSize;
        }
    }

//  End of File