/*

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

*       Methods for Phonebook2 contact item field embedded image reader.

*

*/

// INCLUDE FILES

#include "Pbk2PresentationUtils.h"

#include "CPbk2EmbeddedImage.h"

#include "CPbk2ImageReader.h"

#include "MPbk2ImageOperationObservers.h"

#include "MVPbkBaseContactField.h"

#include "MVPbkStoreContactField.h"

#include "MVPbkContactFieldBinaryData.h"

#include "CVPbkContactManager.h"

#include "TVPbkFieldTypeMapping.h"

#include "MVPbkFieldType.h"

#include "CPbk2ImageData.h"

#include <e32std.h>

#include <eikappui.h>

#include <imageconversion.h>

#include <aknappui.h>   // CEikAppUi

#include <AknUtils.h>   // TAknLayoutRect

#include <barsread.h>   // TResourceReader

#include <RPbk2LocalizedResourceFile.h>

#include "Pbk2DataCaging.hrh"

#include <Pbk2Presentation.rsg>

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicReadPreCond_Constructor = 1,

    EPanicReadPreCond_StartReadL,

    EPanicWritePreCond_Constructor = 100,

    EPanicWritePreCond_CreateImageWriterL,

    EPanicWritePreCond_StoreImageL_CMdaImageDataWriteUtility

    };

#endif // _DEBUG

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

#ifdef _DEBUG

void Panic(TPanicCode aPanicCode)

    {

    _LIT(KPanicText, "CPbkEmbeddedImage");

    User::Panic(KPanicText, aPanicCode);

    }

#endif // _DEBUG

}  // namespace

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

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

// CPbk2EmbeddedImageReader::CPbk2EmbeddedImageReader

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

//

inline CPbk2EmbeddedImageReader::CPbk2EmbeddedImageReader

        (const MVPbkBaseContactField& aField, 

        MPbk2ImageGetObserver& aObserver) :

    CPbk2ImageReaderBase(aObserver),

    iField(aField)

    {

    __ASSERT_DEBUG(iField.FieldData().DataType()==EVPbkFieldStorageTypeBinary, 

        Panic(EPanicReadPreCond_Constructor));

    }

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

// CPbk2EmbeddedImageReader::ConstructL

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

//

inline void CPbk2EmbeddedImageReader::ConstructL()

    {

    CPbk2ImageReaderBase::ConstructL();

    }

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

// CPbk2EmbeddedImageReader::NewLC

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

//

CPbk2EmbeddedImageReader* CPbk2EmbeddedImageReader::NewLC

        (const MVPbkBaseContactField& aField,

        MPbk2ImageGetObserver& aObserver)

    {

    CPbk2EmbeddedImageReader* self = 

        new(ELeave) CPbk2EmbeddedImageReader(aField,aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CPbk2EmbeddedImageReader::~CPbk2EmbeddedImageReader

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

//

CPbk2EmbeddedImageReader::~CPbk2EmbeddedImageReader()

    {

    delete iImageBuffer;

    }

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

// CPbk2EmbeddedImageReader::StartReadL

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

//

void CPbk2EmbeddedImageReader::StartReadL(

        const TPbk2ImageManagerParams* aParameters)

    {

    if (iImageBuffer)

        {

        delete iImageBuffer;

        iImageBuffer = NULL;

        }

    iImageBuffer = 

    	MVPbkContactFieldBinaryData::Cast(iField.FieldData()).BinaryData().AllocL();

    __ASSERT_DEBUG(iImageBuffer && iImageBuffer->Length()>0, 

        Panic(EPanicReadPreCond_StartReadL));

    CancelRead();

    if (iImageBuffer)

        {

        ImageReader().ReadFromBufferL(*iImageBuffer, aParameters);

        }

    }

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

// CPbk2EmbeddedImageReader::ImageBuffer

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

//    

const TDesC8& CPbk2EmbeddedImageReader::ImageBuffer() const    

	{

	if (iImageBuffer)

		{

		return *iImageBuffer;		

		}

	return KNullDesC8;

	}

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

// CPbk2EmbeddedImageWriter::CPbk2EmbeddedImageWriter

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

//

inline CPbk2EmbeddedImageWriter::CPbk2EmbeddedImageWriter

        (CVPbkContactManager& aContactManager,

        MVPbkStoreContactField& aField, 

        MPbk2ImageSetObserver& aObserver) :

    CPbk2ImageWriterBase(aObserver), 

    iContactManager(aContactManager), 

    iField(aField)   

    {

    __ASSERT_DEBUG(iField.FieldData().DataType()==EVPbkFieldStorageTypeBinary, 

        Panic(EPanicWritePreCond_Constructor));

    }

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

// CPbk2EmbeddedImageWriter::ConstructL

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

//

inline void CPbk2EmbeddedImageWriter::ConstructL()

    {

    CPbk2ImageWriterBase::ConstructL();

    }

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

// CPbk2EmbeddedImageWriter::NewLC

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

//

CPbk2EmbeddedImageWriter* CPbk2EmbeddedImageWriter::NewLC

        (CVPbkContactManager& aContactManager,

        MVPbkStoreContactField& aField, 

        MPbk2ImageSetObserver& aObserver)

    {

    CPbk2EmbeddedImageWriter* self = 

        new(ELeave) CPbk2EmbeddedImageWriter(

            aContactManager, aField, aObserver );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CPbk2EmbeddedImageWriter::~CPbk2EmbeddedImageWriter

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

//

CPbk2EmbeddedImageWriter::~CPbk2EmbeddedImageWriter()

    {

    delete iBitmapBlob;

    }

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

// CPbk2EmbeddedImageWriter::CreateImageWriterL

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

//

CImageEncoder* CPbk2EmbeddedImageWriter::CreateImageWriterL()

    {

    __ASSERT_DEBUG(!iBitmapBlob, 

        Panic(EPanicWritePreCond_CreateImageWriterL));

    return CImageEncoder::DataNewL

        (iBitmapBlob, CImageEncoder::EOptionNone, KImageTypeJPGUid);

    }

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

// CPbk2EmbeddedImageWriter::StoreImageL

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

//

void CPbk2EmbeddedImageWriter::StoreImageL(const MPbk2ImageData& aImageData)

    {

    MVPbkContactFieldBinaryData::Cast(iField.FieldData())

    	.SetBinaryDataL(aImageData.GetBufferL());

    }

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

// CPbk2EmbeddedImageWriter::StoreImageL

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

//    

void CPbk2EmbeddedImageWriter::StoreImageL

        (CImageEncoder& /*aImageWriter*/)

    {

    __ASSERT_DEBUG(iBitmapBlob, 

        Panic(EPanicWritePreCond_StoreImageL_CMdaImageDataWriteUtility));

    MVPbkContactFieldBinaryData::Cast(iField.FieldData())

    	.SetBinaryDataL(*iBitmapBlob);    

    }

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

// CPbk2EmbeddedImageWriter::DoCancel

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

//

void CPbk2EmbeddedImageWriter::DoCancel()

    {

    delete iBitmapBlob;

    iBitmapBlob = NULL;

    // Let base class do its own canceling

    CPbk2ImageWriterBase::DoCancel();

    }

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

// CPbk2EmbeddedImageWriter::ImageSize

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

//

TSize CPbk2EmbeddedImageWriter::ImageSize() const

    {

    TBool isCodImage (EFalse);

    TRAP_IGNORE(isCodImage = IsCodImageL());

    if (isCodImage)

    	{

	    return (static_cast<CEikAppUi*>(CCoeEnv::Static()->AppUi()))->

            ApplicationRect().Size();   

    	}

    else 

    	{

	    return KPbk2PersonalImageSize;    	

    	}

    }

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

// CPbk2EmbeddedImageWriter::IsCodImageL

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

//    

TBool CPbk2EmbeddedImageWriter::IsCodImageL() const

	{

    // If iField's type is 

    // 		EVPbkNonVersitCodImage return ETrue otherwise EFalse.

    const MVPbkFieldTypeList& masterFieldTypeList = 

    	iContactManager.FieldTypes();

	RPbk2LocalizedResourceFile resFile(*CCoeEnv::Static());

    resFile.OpenLC(KPbk2RomFileDrive, 

                   KDC_RESOURCE_FILES_DIR,

                   Pbk2PresentationUtils::PresentationResourceFile());

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC(reader, R_CODIMAGE_FIELD_TYPE);

    const TInt count = reader.ReadInt16();

    TBool found(EFalse);

    for (TInt i = 0; i < count && !found; ++i)

        {

        TVPbkFieldTypeMapping mapping(reader);

        const MVPbkFieldType* fieldType = 

            mapping.FindMatch(masterFieldTypeList);

        if (!fieldType)

            {

            User::Leave(KErrNotFound);

            }

        if (IsSameFieldType(*fieldType))

        	{

        	found = ETrue;

        	}

        }

    CleanupStack::PopAndDestroy(2); // resFile, CreateResourceReaderLC

	return found;	

	}

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

// CPbk2EmbeddedImageWriter::IsSameFieldType

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

//	

TBool CPbk2EmbeddedImageWriter::IsSameFieldType(

        const MVPbkFieldType& aFieldType ) const

	{

    TInt maxMatchPriority(iContactManager.FieldTypes().MaxMatchPriority());

    for ( TInt matchPriority = 0; 

    	  matchPriority <= maxMatchPriority; 

    	  ++matchPriority )

        {            

        const MVPbkFieldType* fieldType = 

            iField.MatchFieldType(matchPriority);

        if (fieldType && fieldType->IsSame(aFieldType))

            {

            return ETrue;

            }

        }	

    return EFalse;

    }

//  End of File