1 // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @internalTechnology

    19 */

    20 

    21 #include <e32base.h>

    22 #include <e32property.h>

    23 #include <fbs.h>

    24 #include <caf/content.h>

    25 #include <icl/imagedata.h>

    26 #include <sysutil.h>

    27 #include <pathinfo.h> // PathInfo

    28 #include <bautils.h> // FileExists

    29 #include <mtp/cmtptypeopaquedata.h>

    30 #include "cmtpimagedpthumbnailcreator.h"

    31 #include "mtpimagedpconst.h"

    32 #include "mtpimagedputilits.h"

    33 

    34 __FLOG_STMT(_LIT8(KComponent,"CMTPImageDpThumbnailCreator");)

    35 // --------------------------------------------------------------------------

    36 // CMTPImageDpThumbnailCreator::NewL

    37 // 2-phased constructor.

    38 // --------------------------------------------------------------------------

    39 //

    40 CMTPImageDpThumbnailCreator* CMTPImageDpThumbnailCreator::NewL()

    41     {

    42     CMTPImageDpThumbnailCreator* self= new (ELeave) CMTPImageDpThumbnailCreator();

    43     CleanupStack::PushL(self);

    44     self->ConstructL();

    45     CleanupStack::Pop(self);

    46     return self;

    47     }

    48  

    49 // --------------------------------------------------------------------------

    50 // CMTPImageDpThumbnailCreator::~CMTPImageDpThumbnailCreator

    51 // C++ destructor.

    52 // --------------------------------------------------------------------------

    53 //    

    54 CMTPImageDpThumbnailCreator::~CMTPImageDpThumbnailCreator()

    55     {

    56     __FLOG(_L8(">> ~CMTPImageDpThumbnailCreator"));

    57     Cancel();

    58     if(EGetting == iState)

    59         {

    60         iThumbMgr->CancelRequest(iCurrentReq);

    61         }

    62     delete iData;

    63     delete iImgEnc;

    64 #ifdef MTPTHUMBSCALING

    65     delete iScaler;

    66 #endif

    67     delete iBitmap;  

    68     delete iObjectSource;

    69     delete iThumbMgr;

    70     if(iActiveSchedulerWait->IsStarted())

    71         {

    72         *iCreationErr = KErrNotReady;

    73         iActiveSchedulerWait->AsyncStop();

    74         }

    75     delete iActiveSchedulerWait;

    76     __FLOG(_L8("<< ~CMTPImageDpThumbnailCreator"));

    77     __FLOG_CLOSE;

    78     }

    79  

    80 // --------------------------------------------------------------------------

    81 // CMTPImageDpThumbnailCreator::CMTPImageDpThumbnailCreator

    82 // C++ constructor.

    83 // --------------------------------------------------------------------------

    84 //    

    85 CMTPImageDpThumbnailCreator::CMTPImageDpThumbnailCreator(): 

    86 CActive(EPriorityStandard)

    87     {

    88     __FLOG_OPEN(KMTPSubsystem, KComponent);

    89     __FLOG(_L8("CMTPImageDpThumbnailCreator::CMTPImageDpThumbnailCreator(), begin"));

    90     CActiveScheduler::Add(this);  

    91     __FLOG(_L8("CMTPImageDpThumbnailCreator::CMTPImageDpThumbnailCreator(), end"));

    92     }

    93 

    94 // --------------------------------------------------------------------------

    95 // CMTPImageDpThumbnailCreator::ConstructL

    96 // 2nd phase constructor.

    97 // --------------------------------------------------------------------------

    98 //

    99 void CMTPImageDpThumbnailCreator::ConstructL()

   100     {

   101     __FLOG(_L8("CMTPImageDpThumbnailCreator::ConstructL(), begin"));

   102     iThumbMgr = CThumbnailManager::NewL( *this ); 

   103     iThumbMgr->SetThumbnailSizeL( EFullScreenThumbnailSize );

   104 #ifdef MTPTHUMBSCALING

   105     iScaler = CBitmapScaler::NewL();

   106 #endif    

   107     iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait();

   108     __FLOG(_L8("CMTPImageDpThumbnailCreator::ConstructL(), end"));

   109     }

   110 

   111 // --------------------------------------------------------------------------

   112 // CMTPImageDpThumbnailCreator::DoCancel

   113 // From CActive.

   114 // --------------------------------------------------------------------------

   115 //

   116 void CMTPImageDpThumbnailCreator::DoCancel()

   117     {

   118     __FLOG_VA((_L8(">> CMTPImageDpThumbnailCreator::DoCancel() iState %d iStatus 0x%X"), iState, iStatus.Int()));

   119     switch(iState)

   120         {

   121 #ifdef MTPTHUMBSCALING

   122         case EScaling:

   123             iScaler->Cancel();

   124             break;

   125 #endif

   126         case EEncoding:

   127             iImgEnc->Cancel();

   128             break;

   129         default:

   130             break;

   131         }

   132     if(iActiveSchedulerWait->IsStarted())

   133         {

   134         *iCreationErr = KErrCancel;

   135         iActiveSchedulerWait->AsyncStop();

   136         }

   137     // we will not continue creating thumbs.

   138     __FLOG_VA((_L8("<< CMTPImageDpThumbnailCreator::DoCancel() iState %d"), iState));

   139     }

   140 

   141 // --------------------------------------------------------------------------

   142 // CMTPImageDpThumbnailCreator::RunL

   143 // From CActive.

   144 // --------------------------------------------------------------------------

   145 //    

   146 void CMTPImageDpThumbnailCreator::RunL()

   147     {

   148     __FLOG_VA((_L8(">> CMTPImageDpThumbnailCreator::RunL() iState %d iStatus %d"), iState, iStatus.Int()));

   149     User::LeaveIfError(iStatus.Int());

   150     switch (iState)

   151         { 

   152 #ifdef MTPTHUMBSCALING

   153         case EGetted:

   154             {

   155             ScaleBitmap();

   156             iState = EScaling;

   157             break;

   158             }

   159 #endif

   160         case EScaling:

   161             {

   162             EncodeImageL( );

   163             iState=EEncoding;

   164             break;

   165             }

   166         case EEncoding:

   167             {

   168             iState=EIdle;

   169             if (iThumbMgr->Flags() == CThumbnailManager::EDoNotCreate)

   170                 {

   171                 __FLOG_VA((_L8("CMTPImageDpThumbnailCreator::RunL(),EDoNotCreate; iState %d"), iState));

   172                 delete iData;

   173                 iData = HBufC8::NewL(1);

   174                 iBuffer->Write(*iData);

   175                 }

   176             else{

   177                 iBuffer->Write(*iData);

   178                 }

   179             

   180             __FLOG_VA((_L8("<< CMTPImageDpThumbnailCreator::RunL(),iBuffer->Write(*iData); iState %d"), iState));

   181             if(iActiveSchedulerWait->IsStarted())

   182                 {

   183                 iActiveSchedulerWait->AsyncStop();

   184                 }

   185             break;

   186             }

   187         default:

   188             {

   189             User::Leave(KErrGeneral);

   190             break;

   191             }

   192         }

   193     __FLOG_VA((_L8("<< CMTPImageDpThumbnailCreator::RunL() iState %d"), iState));

   194     }

   195 

   196 // --------------------------------------------------------------------------

   197 // RunError

   198 // --------------------------------------------------------------------------

   199 //    

   200 TInt CMTPImageDpThumbnailCreator::RunError(TInt aErr)

   201     {

   202     __FLOG_VA((_L8(">> CMTPImageDpThumbnailCreator::RunError() err 0x%X"), aErr));

   203     iState=EIdle;

   204     if(iActiveSchedulerWait->IsStarted())

   205         {

   206         *iCreationErr = aErr;

   207         iActiveSchedulerWait->AsyncStop();

   208         }

   209     // no need to cancel iScalerP since only leave is issued if scaler creation fails

   210     __FLOG(_L8("<< CMTPImageDpThumbnailCreator::RunError()"));

   211     return KErrNone;

   212     }

   213 

   214 // --------------------------------------------------------------------------

   215 // 

   216 // --------------------------------------------------------------------------

   217 //

   218 void CMTPImageDpThumbnailCreator::GetThumbnailL(const TDesC& aFileName, CMTPTypeOpaqueData& aThumbName,  TInt& result)

   219     {

   220     __FLOG(_L8(">> CMtpImageDphumbnailCreator::GetThumbnailL()"));

   221     iBuffer = &aThumbName;

   222     GetThumbL(aFileName);

   223     iCreationErr = &result;		//reset the err flag

   224     *iCreationErr = KErrNone;

   225     __FLOG(_L8("<< CMTPImageDpThumbnailCreator::CreateThumbnailL()"));

   226     iActiveSchedulerWait->Start();

   227     }

   228 

   229 // --------------------------------------------------------------------------

   230 // 

   231 // --------------------------------------------------------------------------

   232 //

   233 void CMTPImageDpThumbnailCreator::ClearThumbnailData()

   234     {

   235     delete iData;

   236     iData = NULL;

   237     delete iBitmap;

   238     iBitmap = NULL;

   239     delete iObjectSource;

   240     iObjectSource = NULL;

   241     delete iImgEnc;

   242     iImgEnc = NULL;

   243     }

   244 

   245 void CMTPImageDpThumbnailCreator::GetThumbL(const TDesC& aFileName)

   246     {

   247     __FLOG(_L8(">> CMtpImageDphumbnailCreator::GetThumbL()"));

   248     // Create an object source representing a path to a file on local

   249     // file system.

   250     delete iObjectSource;

   251     iObjectSource = NULL;

   252     

   253     iObjectSource = CThumbnailObjectSource::NewL(aFileName, KJpegMimeType);

   254     iCurrentReq = iThumbMgr->GetThumbnailL( *iObjectSource );

   255     iState = EGetting;

   256     __FLOG(_L8("<< CMtpImageDphumbnailCreator::GetThumbL()"));

   257     }

   258 

   259 #ifdef MTPTHUMBSCALING

   260 // --------------------------------------------------------------------------

   261 // CMTPImageDpThumbnailCreator::ScaleBitmapL

   262 // Scales the bitmap to the thumbnail size.

   263 // --------------------------------------------------------------------------

   264 //

   265 void CMTPImageDpThumbnailCreator::ScaleBitmap()

   266     {

   267     __FLOG(_L8("CMTPImageDpThumbnailCreator::ScaleBitmapL(), begin"));

   268     TSize size( KThumbWidht, KThumbHeigth ); // size 160x120      

   269     // Resize image to thumbnail size 

   270     iScaler->Scale( &iStatus, *iBitmap, size );

   271     SetActive();

   272     __FLOG(_L8("CMTPImageDpThumbnailCreator::ScaleBitmapL(), end"));

   273     }

   274 #endif

   275 

   276 // --------------------------------------------------------------------------

   277 // CMTPImageDpThumbnailCreator::EncodeImageL

   278 // Encodes bitmap as a jpeg image.

   279 // --------------------------------------------------------------------------

   280 //

   281 void CMTPImageDpThumbnailCreator::EncodeImageL( )

   282     {

   283     __FLOG(_L8(">> CMTPImageDpThumbnailCreator::EncodeImageL()"));

   284 

   285     delete iData;

   286     iData = NULL;

   287     

   288     delete iImgEnc;

   289     iImgEnc = NULL;

   290     

   291     // Convert bitmap to jpg

   292     iImgEnc = CImageEncoder::DataNewL( iData, KPtpMimeJPEG, CImageEncoder::EPreferFastEncode );

   293     iImgEnc->Convert( &iStatus, *iBitmap );

   294     SetActive();

   295     __FLOG(_L8("<< CMTPImageDpThumbnailCreator::EncodeImageL()"));

   296     }

   297 

   298 //

   299 //

   300 void CMTPImageDpThumbnailCreator::ThumbnailReady( TInt aError, MThumbnailData& aThumbnail, TThumbnailRequestId aId )

   301     {

   302     // This function must not leave.

   303     __FLOG(_L8(">> CMTPImageDpThumbnailCreator::ThumbnailReady()"));

   304     if(iCurrentReq != aId)

   305         {

   306         __FLOG(_L8("CMTPImageDpThumbnailCreator::ThumbnailReady(),iCurrentReq != aId"));

   307         return;

   308         }

   309     if (aError == KErrNone)

   310         {

   311         TRAP_IGNORE(iThumbMgr->SetFlagsL(CThumbnailManager::EDefaultFlags));

   312         delete iBitmap;   

   313         // Claim ownership of the bitmap instance for later use

   314         iBitmap = aThumbnail.DetachBitmap();

   315 #ifdef MTPTHUMBSCALING

   316         iState = EGetted;

   317 #else

   318         iState = EScaling;				//direct set to Scaling state jump the scaling function

   319 #endif

   320         }

   321     else if ((iThumbMgr->Flags() == CThumbnailManager::EDoNotCreate) && (aError == KErrNotFound))

   322         {

   323         __FLOG(_L8("CMTPImageDpThumbnailCreator::ThumbnailReady(),EDoNotCreate, KErrNotFound"));

   324         iState = EEncoding;

   325         iThumbMgr->CreateThumbnails(*iObjectSource);

   326         aError = KErrNone;

   327         }

   328     iStatus=KRequestPending;

   329     TRequestStatus* status=&iStatus;

   330     User::RequestComplete(status, aError);

   331     SetActive();

   332     __FLOG(_L8("<< CMTPImageDpThumbnailCreator::ThumbnailReady()"));

   333     }

   334 

   335 void CMTPImageDpThumbnailCreator::ThumbnailPreviewReady( MThumbnailData& /*aThumbnail*/, TThumbnailRequestId /*aId*/ )

   336     {

   337     

   338     }

   339 

   340 // End of file