1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *       Methods for Phonebook contact item field embedded thumbnail reader.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 

    22 #include "CPbkEmbeddedThumbnail.h"

    23 #include "CPbkImageReader.h"

    24 #include "MPbkThumbnailOperationObservers.h"

    25 #include "PbkImageData.h"

    26 #include <CPbkFFSCheck.h>

    27 

    28 #include <e32std.h>

    29 #include <eikappui.h>

    30 #include <TPbkContactItemField.h>

    31 #include <imageconversion.h>

    32 

    33 /// Unnamed namespace for local definitions

    34 namespace {

    35 

    36 #ifdef _DEBUG

    37 enum TPanicCode

    38     {

    39     EPanicReadPreCond_Constructor = 1,

    40     EPanicReadPreCond_StartReadL,

    41 

    42     EPanicWritePreCond_Constructor = 100,

    43     EPanicWritePreCond_CreateImageWriterL,

    44     EPanicWritePreCond_StoreImageL_CMdaImageDataWriteUtility

    45     };

    46 #endif

    47 

    48 

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

    50 

    51 #ifdef _DEBUG

    52 void Panic(TPanicCode aPanicCode)

    53     {

    54     _LIT(KPanicText, "CPbkEmbeddedThumbnail");

    55     User::Panic(KPanicText, aPanicCode);

    56     }

    57 #endif

    58 

    59 // When thumbnail image is saved to contactdatabase then during saving

    60 // some extra disk space is consumed besides raw thumbnail data.

    61 // Following const is approximation for this needed extra space.

    62 const TInt KHdOverhead = 1024;

    63 

    64 // Gives approximation for saved thumbnail size on the disk

    65 inline TInt ThumbnailSizeOnDisk(TInt aBytes)

    66     {

    67     return aBytes+KHdOverhead;

    68     }

    69 

    70 }  // namespace

    71 

    72 

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

    74 

    75 /////////////////////////////////////////////////////////////////

    76 // CPbkEmbeddedThumbnailReader 

    77 

    78 inline CPbkEmbeddedThumbnailReader::CPbkEmbeddedThumbnailReader

    79         (const TPbkContactItemField& aField, 

    80         MPbkThumbnailGetObserver& aObserver) :

    81     CPbkThumbnailReaderBase(aObserver),

    82     iField(aField)

    83     {

    84     __ASSERT_DEBUG(iField.StorageType()==KStorageTypeStore, 

    85         Panic(EPanicReadPreCond_Constructor));

    86     }

    87 

    88 inline void CPbkEmbeddedThumbnailReader::ConstructL()

    89     {

    90     CPbkThumbnailReaderBase::ConstructL();    

    91     }

    92 

    93 CPbkEmbeddedThumbnailReader* CPbkEmbeddedThumbnailReader::NewLC

    94         (const TPbkContactItemField& aField,

    95         MPbkThumbnailGetObserver& aObserver)

    96     {

    97     CPbkEmbeddedThumbnailReader* self = 

    98         new(ELeave) CPbkEmbeddedThumbnailReader(aField,aObserver);

    99     CleanupStack::PushL(self);

   100     self->ConstructL();

   101     return self;

   102     }

   103 

   104 CPbkEmbeddedThumbnailReader::~CPbkEmbeddedThumbnailReader()

   105     {

   106     }

   107 

   108 void CPbkEmbeddedThumbnailReader::StartReadL(const TPbkImageLoadParameters* aParameters)

   109     {

   110     HBufC8* imageBuf = iField.ContactItemField().StoreStorage()->Thing();

   111     __ASSERT_DEBUG(imageBuf && imageBuf->Length()>0, 

   112         Panic(EPanicReadPreCond_StartReadL));

   113     CancelRead();

   114 	if (imageBuf)

   115 		{

   116 		ImageReader().ReadFromBufferL(*imageBuf, aParameters);

   117 		}

   118     }

   119 

   120 /////////////////////////////////////////////////////////////////

   121 // CPbkEmbeddedThumbnailImageReader

   122 inline CPbkEmbeddedThumbnailImageReader::CPbkEmbeddedThumbnailImageReader

   123         (const TPbkContactItemField& aField, 

   124         MPbkThumbnailGetImageObserver& aObserver) :

   125     CPbkThumbnailImageReaderBase(aObserver),

   126     iField(aField)

   127     {

   128     __ASSERT_DEBUG(iField.StorageType()==KStorageTypeStore && !iField.IsEmpty(),

   129         Panic(EPanicReadPreCond_Constructor));

   130     }

   131 

   132 CPbkEmbeddedThumbnailImageReader* CPbkEmbeddedThumbnailImageReader::NewLC

   133         (const TPbkContactItemField& aField, 

   134         MPbkThumbnailGetImageObserver& aObserver)

   135     {

   136     CPbkEmbeddedThumbnailImageReader* self = 

   137         new(ELeave) CPbkEmbeddedThumbnailImageReader(aField,aObserver);

   138     CleanupStack::PushL(self);

   139     self->ConstructL();

   140     return self;

   141     }

   142 

   143 void CPbkEmbeddedThumbnailImageReader::ConstructL()

   144     {

   145     CPbkThumbnailImageReaderBase::ConstructL();

   146     }

   147 

   148 CPbkEmbeddedThumbnailImageReader::~CPbkEmbeddedThumbnailImageReader()

   149     {

   150     }

   151 

   152 void CPbkEmbeddedThumbnailImageReader::DoStartReadL(const TPbkImageLoadParameters* aParameters)

   153     {

   154     const TDesC8& imageBuffer = ImageBuffer();

   155     ImageReader().RecognizeFormatFromBufferL(imageBuffer);

   156     ImageReader().ReadFromBufferL(imageBuffer, aParameters);

   157     }

   158 

   159 MPbkImageData* CPbkEmbeddedThumbnailImageReader::CreateImageDataLC()

   160     {

   161     CPbkImageBufferData* imageData = CPbkImageBufferData::NewL(ImageBuffer());

   162     CleanupStack::PushL(imageData);

   163     return imageData;

   164     }

   165 

   166 const TDesC8& CPbkEmbeddedThumbnailImageReader::ImageBuffer() const

   167     {

   168     return *(iField.ContactItemField().StoreStorage()->Thing());

   169     }

   170 

   171 

   172 /////////////////////////////////////////////////////////////////

   173 // CPbkEmbeddedThumbnailWriter

   174 

   175 inline CPbkEmbeddedThumbnailWriter::CPbkEmbeddedThumbnailWriter

   176         (TPbkContactItemField& aField, 

   177         MPbkThumbnailSetObserver& aObserver) :

   178     CPbkThumbnailWriterBase(aObserver), iField(aField)   

   179     {

   180     __ASSERT_DEBUG(iField.StorageType()==KStorageTypeStore, 

   181         Panic(EPanicWritePreCond_Constructor));

   182     }

   183 

   184 inline void CPbkEmbeddedThumbnailWriter::ConstructL()

   185     {

   186     CPbkThumbnailWriterBase::ConstructL();

   187     iFFSCheck=CPbkFFSCheck::NewL();

   188     }

   189 

   190 CPbkEmbeddedThumbnailWriter* CPbkEmbeddedThumbnailWriter::NewLC

   191         (TPbkContactItemField& aField, 

   192         MPbkThumbnailSetObserver& aObserver)

   193     {

   194     CPbkEmbeddedThumbnailWriter* self = 

   195         new(ELeave) CPbkEmbeddedThumbnailWriter(aField, aObserver);

   196     CleanupStack::PushL(self);

   197     self->ConstructL();

   198     return self;

   199     }

   200 

   201 CPbkEmbeddedThumbnailWriter::~CPbkEmbeddedThumbnailWriter()

   202     {

   203     delete iBitmapBlob;

   204     delete iFFSCheck;

   205     }

   206 

   207 CImageEncoder* CPbkEmbeddedThumbnailWriter::CreateImageWriterL()

   208     {

   209     __ASSERT_DEBUG(!iBitmapBlob, Panic(EPanicWritePreCond_CreateImageWriterL));

   210 

   211     return CImageEncoder::DataNewL

   212         (iBitmapBlob, CImageEncoder::EOptionNone, KImageTypeJPGUid);

   213     }

   214 

   215 void CPbkEmbeddedThumbnailWriter::StoreImageL(const MPbkImageData& aImageData)

   216     {

   217     const TDesC8& imageBuffer = aImageData.GetBufferL();

   218     if(iFFSCheck->FFSClCheckL(ThumbnailSizeOnDisk(imageBuffer.Length())))

   219         {

   220         iField.ContactItemField().StoreStorage()->SetThingL(imageBuffer);

   221         }    

   222     }

   223 

   224 void CPbkEmbeddedThumbnailWriter::StoreImageL

   225         (CImageEncoder& /*aImageWriter*/)

   226     {

   227     __ASSERT_DEBUG(iBitmapBlob, 

   228         Panic(EPanicWritePreCond_StoreImageL_CMdaImageDataWriteUtility));

   229     if(iFFSCheck->FFSClCheckL(ThumbnailSizeOnDisk(iBitmapBlob->Length())))

   230         {

   231         iField.ContactItemField().StoreStorage()->SetThingL(*iBitmapBlob);        

   232         }

   233     }

   234 

   235 void CPbkEmbeddedThumbnailWriter::DoCancel()

   236     {

   237     delete iBitmapBlob;

   238     iBitmapBlob = NULL;

   239 

   240     // Let base class do its own canceling

   241     CPbkThumbnailWriterBase::DoCancel();

   242     }

   243 

   244 TSize CPbkEmbeddedThumbnailWriter::ImageSize() const

   245     {

   246     if (EPbkFieldIdCodImageID==iField.PbkFieldId())

   247         {

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

   249             ApplicationRect().Size();

   250         }

   251     else 

   252         {

   253         //Default: EPbkFieldIdThumbnailImage

   254         return KPbkPersonalImageSize;

   255         }

   256     }

   257 

   258 //  End of File