MCL/sf/mw/imghandling: comparison imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailrequestactive.cpp

equal deleted inserted replaced

-:2b4b06654caa
+:6257223ede8a
 #include "thumbnaildataimpl.h"
 #include "thumbnailpanic.h"
 #include "thumbnaillog.h"
 #include "thumbnailmanagerimpl.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "thumbnailrequestactiveTraces.h"
+#endif
 // ======== MEMBER FUNCTIONS ========
 // ---------------------------------------------------------------------------
 // CThumbnailRequestActive::~CThumbnailRequestActive()
 ,iRetry(0)
 #endif
 {
 CActiveScheduler::Add( this );
 TN_DEBUG2( "CThumbnaiRequestActive::CThumbnailRequestActive() AO's priority = %d", Priority());
+OstTrace1( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_CTHUMBNAILREQUESTACTIVE, "CThumbnailRequestActive::CThumbnailRequestActive - AO's priority;Priority()=%d", Priority() );
 iBitmap = NULL;
 iRequestCompleted = EFalse;
 }
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::StartL()
 {
 TN_DEBUG3( "CThumbnailRequestActive::StartL(0x%08x) reqid = %d", this, iRequestId );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL;iRequestId=%u", iRequestId );
 iRequestActive = ETrue;
 #ifdef _DEBUG
 TTime stop;
 stop.UniversalTime();
 TN_DEBUG3( "CThumbnailRequestActive::StartL() req id = %d, queuing time %d ms",
+iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
+OstTraceExt2( TRACE_NORMAL, DUP1_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL - req id = %d, queuing time %d ms",
 iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
 #endif
 switch (iRequestType)
 {
 // custom thumbnails are never stored in db
 if (iParams.iThumbnailSize == ECustomThumbnailSize &&
 iParams.iOriginalControlFlags != EThumbnailGeneratePersistentSizesOnly)
 {
 TN_DEBUG1( "CThumbnaiRequestActive::StartL()- custom size request" );
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL - custom size request" );
 iFile.Close();
 User::LeaveIfError( iFile.Open( iFs, iPath, EFileShareReadersOrWriters ) );
 TN_DEBUG2( "CThumbnailRequestActive::StartL() - file handle opened for %S", &iPath );
+OstTraceExt1( TRACE_NORMAL, DUP3_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL;iPath=%S", iPath );
 CleanupClosePushL( iFile );
 if ( iParams.iQualityPreference == CThumbnailManager::EOptimizeForQualityWithPreview )
 {
 // open file handle
 iFile.Close();
 User::LeaveIfError( iFile.Open( iFs, iTargetUri, EFileShareReadersOrWriters ) );
 TN_DEBUG2( "CThumbnailRequestActive::StartL() - file handle opened for %S", &iTargetUri );
+OstTraceExt1( TRACE_NORMAL, DUP4_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL - file handle opened;iTargetUri=%S", iTargetUri );
 CleanupClosePushL( iFile );
 if ( iParams.iQualityPreference == CThumbnailManager::EOptimizeForQualityWithPreview )
 {
 // open file handle
 iFile.Close();
 User::LeaveIfError( iFile.Open( iFs, iParams.iFileName, EFileShareReadersOrWriters ) );
 TN_DEBUG2( "CThumbnailRequestActive::StartL() - file handle opened for %S", &iParams.iFileName );
+OstTraceExt1( TRACE_NORMAL, DUP5_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL;iParams.iFileName=%S", iParams.iFileName );
 CleanupClosePushL( iFile );
 if ( iParams.iQualityPreference == CThumbnailManager::EOptimizeForQualityWithPreview )
 {
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::RunL()
 {
 TN_DEBUG2( "CThumbnailRequestActive::RunL() - request ID: %d", iParams.iRequestId );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u", iParams.iRequestId );
 if ( iParams.iControlFlags == EThumbnailPreviewThumbnail )
 {
 iRequestCompleted = EFalse;
 		iProcessingPreview = ETrue;
 #ifdef _DEBUG
 TTime stop;
 stop.UniversalTime();
 TN_DEBUG3( "CThumbnailRequestActive::RunL() total execution time of req %d is %d ms",
 iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
+OstTraceExt2( TRACE_NORMAL, DUP1_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - total execution time of req %d is %d ms",
+iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
 #endif
 }
 else if (iCanceled || iRequestType == EReqRenameThumbnails)
 {
 if (iCanceled)
 #ifdef _DEBUG
 TTime stop;
 stop.UniversalTime();
 TN_DEBUG3( "CThumbnailRequestActive::RunL() total execution time of req %d is %d ms",
 iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
+OstTraceExt2( TRACE_NORMAL, DUP2_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - total execution time of req %d is %d ms",
+iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
 #endif
 }
 else if ( iStatus.Int() == KThumbnailErrThumbnailNotFound && iParams.iFileName.Length() &&
 !( iParams.iFlags& CThumbnailManager::EDoNotCreate ))
 {
 TN_DEBUG2( "CThumbnaiRequestActive::RunL() - no thumbnail found - lets try with file handle %S", &iParams.iFileName );
+OstTraceExt1( TRACE_NORMAL, DUP3_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - no thumbnail found - lets try with file handle;iParams.iFileName=%S", iParams.iFileName );
 iRequestCompleted = EFalse;
 // We tried to get thumbnail using file path, but it was not found in
 // the database. We need to open the file now (on the client side) and
 // use file handle.
 iFile.Close();
 TInt err = iFile.Open( iFs, iParams.iFileName, EFileShareReadersOrWriters );
 TN_DEBUG2( "CThumbnaiRequestActive::RunL() - file handle open err = %d", err );
+OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - file handle open err;err=%d", err );
 User::LeaveIfError( err );
 CleanupClosePushL( iFile );
 TN_DEBUG2( "CThumbnaiRequestActive::RunL() - file handle opened for %S", &iParams.iFileName );
+OstTraceExt1( TRACE_NORMAL, DUP5_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iFileName=%S", iParams.iFileName );
 iSession.RequestThumbnailL( iFile, iParams.iFileName, iParamsPckg, iStatus );
 CleanupStack::PopAndDestroy( &iFile );
 iTimer->Start( KClientRequestTimeout, KClientRequestTimeout,
 }
 //1st round thumb ready from exif (stored)
 else if (iParams.iOriginalControlFlags == EThumbnailGeneratePersistentSizesOnly && !iProcessingPreview)
 	    {
 	    TN_DEBUG1( "CThumbnaiRequestActive::RunL()- generate persistent sizes thumbnailready" );
+	    OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - generate persistent sizes thumbnailready" );
 	    iBitmapHandle = iParams.iBitmapHandle;
 	    TN_DEBUG2( "CThumbnaiRequestActive::RunL() - iObserver.ThumbnailReady %d", iParams.iRequestId );
+	    OstTrace1( TRACE_NORMAL, DUP7_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u", iParams.iRequestId );
 	    iObserver.ThumbnailReady( iStatus.Int(), *iCallbackThumbnail, iParams.iRequestId );
 	    ReleaseServerBitmap();
 	    iFile.Close();
 #ifdef _DEBUG
 TTime stop;
 stop.UniversalTime();
 TN_DEBUG3( "CThumbnailRequestActive::RunL() total execution time %d, %d ms",
 iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
+OstTraceExt2( TRACE_NORMAL, DUP8_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - total execution time %d, %d ms",
+iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
 #endif
 	    }
 //1st round preview ready from too low quality exif/exif not found (not-stored)
 //relauch using normal decoding
 else if (iParams.iOriginalControlFlags == EThumbnailGeneratePersistentSizesOnly && iProcessingPreview)
 {
 TN_DEBUG1( "CThumbnaiRequestActive::RunL()- generate persistent sizes thumbnailpreviewready" );
+OstTrace0( TRACE_NORMAL, DUP9_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - generate persistent sizes thumbnailpreviewready" );
 iBitmapHandle = iParams.iBitmapHandle;
 TN_DEBUG2( "CThumbnaiRequestActive::RunL() - iObserver.ThumbnailPreviewReady %d", iParams.iRequestId );
+OstTrace1( TRACE_NORMAL, DUP10_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u", iParams.iRequestId );
 iObserver.ThumbnailPreviewReady( *iCallbackThumbnail, iParams.iRequestId );
 iProcessingPreview = EFalse;
 ReleaseServerBitmap();
 	#endif
 }
 else
 {
 TN_DEBUG1( "CThumbnailRequestActive::RunL() - succesful" );
+OstTrace0( TRACE_NORMAL, DUP11_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - succesful" );
 // Success
 iBitmapHandle = iParams.iBitmapHandle;
 if( iBitmapHandle )
 CleanupStack::Pop( bitmap );
 // reduce bpp value (displaymode to match reqested bits per pixel)
 #ifdef _DEBUG
 TN_DEBUG2( "CThumbnailRequestActive::RunL() - displaymode is %d", bitmap->DisplayMode());
+OstTrace1( TRACE_NORMAL, DUP12_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;bitmap->DisplayMode()=%u", bitmap->DisplayMode() );
 #endif
 if( bitmap->DisplayMode() > iParams.iDisplayMode )
 {
 bitmap->SetDisplayMode( iParams.iDisplayMode );
 #ifdef _DEBUG
 TN_DEBUG2( "CThumbnailRequestActive::RunL() - displaymode is now %d", bitmap->DisplayMode());
+OstTrace1( TRACE_NORMAL, DUP13_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;bitmap->DisplayMode()=%u", bitmap->DisplayMode() );
 #endif
 }
 iCallbackThumbnail->Set( bitmap, iClientData );
 bitmap = NULL; // Owned by iCallbackThumbnail or client now
 }
 if ( iProcessingPreview )
 {
 TN_DEBUG2( "CThumbnailRequestActive::RunL() - iObserver.ThumbnailPreviewReady %d", iParams.iRequestId );
+			OstTrace1( TRACE_NORMAL, DUP14_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - iObserver.ThumbnailPreviewReady;iParams.iRequestId=%u", iParams.iRequestId );
 //increase priority of 2nd round (both, AO and request itself)
 this->SetPriority(this->Priority() + 1);
 iParams.iPriority++;
 iObserver.ThumbnailPreviewReady( *iCallbackThumbnail, iParams.iRequestId );
 Get2ndPhaseThumbnailL();
 }
 else
 {
 TN_DEBUG2( "CThumbnailRequestActive::RunL() - iObserver.ThumbnailReady %d", iParams.iRequestId );
+OstTrace1( TRACE_NORMAL, DUP15_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u", iParams.iRequestId );
 iObserver.ThumbnailReady( iStatus.Int(), * iCallbackThumbnail, iParams.iRequestId );
 ReleaseServerBitmap();
 iFile.Close();
 iRequestQueue->RequestComplete(this);
 #ifdef _DEBUG
 TTime stop;
 stop.UniversalTime();
+TInt tookTime = (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000;
 TN_DEBUG4( "CThumbnailRequestActive::RunL(0x%08x) total execution time of req %d is %d ms",
 this, iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );
+OstTrace1( TRACE_NORMAL, DUP16_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;this=%o", this );
+OstTraceExt2( TRACE_NORMAL, DUP17_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u;tookTime=%d", iParams.iRequestId, tookTime );
 #endif
 }
 }
 delete iBitmap;
 // ---------------------------------------------------------------------------
 //
 TInt CThumbnailRequestActive::RunError( TInt aError )
 {
 TN_DEBUG1( "CThumbnailRequestActive::RunError");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_RUNERROR, "CThumbnailRequestActive::RunError" );
 iTimer->Cancel();
 // If RunL() left, the client did not get any callbacks yet.
 // We need to notify it of the error now.
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::DoCancel()
 {
 TN_DEBUG1( "CThumbnailRequestActive::DoCancel");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_DOCANCEL, "CThumbnailRequestActive::DoCancel" );
 iTimer->Cancel();
 __ASSERT_DEBUG(( iRequestId > 0 ), ThumbnailPanic( EThumbnailWrongId ));
 iCanceled = ETrue;
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::AsyncCancel()
 {
 TN_DEBUG1( "CThumbnailRequestActive::AsyncCancel");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_ASYNCCANCEL, "CThumbnailRequestActive::AsyncCancel" );
 __ASSERT_DEBUG(( iRequestId > 0 ), ThumbnailPanic( EThumbnailWrongId ));
 iCanceled = ETrue;
 iSession.CancelRequest( iRequestId );
 void CThumbnailRequestActive::ReleaseServerBitmap()
 {
 if ( iBitmapHandle && iSession.Handle())
 {
 	TN_DEBUG1( "CThumbnailRequestActive::ReleaseServerBitmap");
+	OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_RELEASESERVERBITMAP, "CThumbnailRequestActive::ReleaseServerBitmap" );
 iSession.ReleaseBitmap( iBitmapHandle );
 iBitmapHandle = 0;
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::HandleError()
 {
 TN_DEBUG1( "CThumbnailRequestActive::HandleError");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError" );
 if ( iError )
 {
 if( iError == KErrServerTerminated)
 {
 iSession.Close();
 TInt connErr = iSession.Connect();
 if (connErr != KErrNone)
 {
 TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - session reconnect err %d", connErr );
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError;err=%d", connErr );
 }
 else
 {
 TN_DEBUG1( "CThumbnailRequestActive::HandleError() - session reconnected");
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError - session reconnected" );
 }
 }
 if (iRequestObserver && iRequestType == EReqDeleteThumbnails)
 {
 TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - iRequestObserver->ThumbnailRequestReady %d", iParams.iRequestId );
+OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError;iParams.iRequestId=%u", iParams.iRequestId );
 iRequestObserver->ThumbnailRequestReady(iError, ERequestDeleteThumbnails ,iParams.iRequestId);
 }
 else
 {
 			 iCallbackThumbnail->Set( NULL, iClientData );
 if(iRetry < KMaxRequestRetryCount )
 {
 iRetry++;
 TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - KErrServerTerminated, retry %d", iRetry);
+OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError - KErrServerTerminated;iRetry=%d", iRetry );
 iError = KErrNone;
 TRAPD(err, StartL());
 return;
 }
 	            }
 #endif
 	        TN_DEBUG3( "CThumbnaiRequestActive::HandleError() - iObserver.ThumbnailReady req=%d err=%d", iParams.iRequestId, iError );
+	        OstTrace1( TRACE_NORMAL, DUP5_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError - iObserver.ThumbnailReady %u", iParams.iRequestId );
 	        iObserver.ThumbnailReady( iError, *iCallbackThumbnail, iParams.iRequestId );
 }
 iError = KErrNone;
 // CThumbnailRequestActive::GetThumbnailL()
 // Get a thumbnail for an object file.
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::GetThumbnailL( const RFile64& aFile, TThumbnailId aThumbnailId,
-CThumbnailManager::TThumbnailFlags aFlags, CThumbnailManager
+const TDesC8& aMimeType, CThumbnailManager::TThumbnailFlags aFlags, CThumbnailManager
 ::TThumbnailQualityPreference aQualityPreference, const TSize& aSize, const
 TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData, TBool aGeneratePersistentSizesOnly,
 const TDesC& aTargetUri, TThumbnailSize aThumbnailSize)
 {
 iRequestType = EReqGetThumbnailHandle;
 iClientData = aClientData;
 iParams.iControlFlags = (aGeneratePersistentSizesOnly ?
 						EThumbnailGeneratePersistentSizesOnly :
 						EThumbnailNoControlFlags);
 iParams.iOriginalControlFlags = iParams.iControlFlags;
+iParams.iMimeType = TDataType( aMimeType );
 iParams.iBitmapHandle = 0;
 iParams.iSize = aSize;
 iParams.iDisplayMode = aDisplayMode;
 User::LeaveIfError( aFile.FullName( iParams.iFileName ));
 iParams.iRequestId = iRequestId;
 // CThumbnailRequestActive::GetThumbnailL()
 // Get a thumbnail opening an object file later.
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::GetThumbnailL( TThumbnailId aThumbnailId,
-const TDesC& aPath, CThumbnailManager::TThumbnailFlags aFlags, CThumbnailManager
+const TDesC& aPath, const TDesC8& aMimeType, CThumbnailManager::TThumbnailFlags aFlags,
-::TThumbnailQualityPreference aQualityPreference, const TSize& aSize, const
+CThumbnailManager::TThumbnailQualityPreference aQualityPreference, const TSize& aSize, const
 TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData, TBool aGeneratePersistentSizesOnly,
 const TDesC& aTargetUri, TThumbnailSize aThumbnailSize)
 {
 iRequestType = EReqGetThumbnailHandleLater;
 iClientData = aClientData;
 iParams.iControlFlags = (aGeneratePersistentSizesOnly ?
 EThumbnailGeneratePersistentSizesOnly :
 EThumbnailNoControlFlags);
 iParams.iOriginalControlFlags = iParams.iControlFlags;
+iParams.iMimeType = TDataType( aMimeType );
 iParams.iBitmapHandle = 0;
 iParams.iSize = aSize;
 iParams.iDisplayMode = aDisplayMode;
 iParams.iFileName = aPath;
 iParams.iRequestId = iRequestId;
 // CThumbnailRequestActive::GetThumbnailL()
 // Get a thumbnail for an object file.
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::GetThumbnailL( const TDesC& aPath, TThumbnailId aThumbnailId,
-CThumbnailManager::TThumbnailFlags aFlags, CThumbnailManager
+const TDesC8& aMimeType, CThumbnailManager::TThumbnailFlags aFlags, CThumbnailManager
 ::TThumbnailQualityPreference aQualityPreference, const TSize& aSize, const
 TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData, TBool aGeneratePersistentSizesOnly,
 const TDesC& aTargetUri, TThumbnailSize aThumbnailSize)
 {
 iRequestType = EReqGetThumbnailPath;
 iClientData = aClientData;
 iParams.iControlFlags = (aGeneratePersistentSizesOnly ?
 						EThumbnailGeneratePersistentSizesOnly :
 						EThumbnailNoControlFlags);
 iParams.iOriginalControlFlags = iParams.iControlFlags;
+iParams.iMimeType = TDataType( aMimeType );
 iParams.iBitmapHandle = 0;
 iParams.iSize = aSize;
 iParams.iDisplayMode = aDisplayMode;
 iParams.iRequestId = iRequestId;
 iParams.iPriority = aPriority;
 }
 else if (!iParams.iVirtualUri)
 {
 // memory low, create thumbs using filehandle
 TN_DEBUG1( "CThumbnaiRequestActive::SetThumbnailbyBitmap() - memory low, create thumbs using filehandle!" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_SETTHUMBNAILL, "CThumbnailRequestActive::SetThumbnailL - memory low, create thumbs using filehandle!" );
 delete aBitmap;
 aBitmap = NULL;
 iParams.iPriority = aPriority - 1;
 iRequestType = EReqGetThumbnailHandleLater;
 }
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::Get2ndPhaseThumbnailL()
 {
 TN_DEBUG2( "CThumbnailRequestActive::Get2ndPhaseThumbnailL() %d", iParams.iRequestId );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_GET2NDPHASETHUMBNAILL, "CThumbnailRequestActive::Get2ndPhaseThumbnailL;iParams.iRequestId=%u", iParams.iRequestId );
 iParams.iQualityPreference = CThumbnailManager::EOptimizeForQuality;
 iParams.iControlFlags = EThumbnailNoControlFlags;
 if ( iMyFileHandle.SubSessionHandle())
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::ChangePriority( const TInt aNewPriority )
 {
 TN_DEBUG1( "CThumbnailRequestActive::ChangePriority");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_CHANGEPRIORITY, "CThumbnailRequestActive::ChangePriority" );
 iParams.iPriority = aNewPriority;
 if (!IsActive())
 {
 // ---------------------------------------------------------------------------
 //
 void CThumbnailRequestActive::StartError( const TInt aErr )
 {
 TN_DEBUG1( "CThumbnailRequestActive::StartError");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_STARTERROR, "CThumbnailRequestActive::StartError" );
 iStartError = aErr;
 iRequestActive = ETrue;
 if (!iTimer->IsActive())
 // ---------------------------------------------------------------------------
 //
 TInt CThumbnailRequestActive::TimerCallBack(TAny* aAny)
 {
 TN_DEBUG1( "CThumbnailRequestActive::TimerCallBack() - request timeout");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_TIMERCALLBACK, "CThumbnailRequestActive::TimerCallBack" );
 CThumbnailRequestActive* self = static_cast<CThumbnailRequestActive*>( aAny );
 self->iTimer->Cancel();
 }
 self->HandleError();
 TN_DEBUG1( "CThumbnailRequestActive::TimerCallBack() - end");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILREQUESTACTIVE_TIMERCALLBACK, "CThumbnailRequestActive::TimerCallBack - end" );
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 }
 // virtual URI
 else
 {
 TN_DEBUG1( "CThumbnailRequestActive::IsVirtualUri() - yes");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_ISVIRTUALURI, "CThumbnailRequestActive::IsVirtualUri - yes" );
 return ETrue;
 }
 }
 // End of file

branch	RCL_3
changeset 21	6257223ede8a
parent 20	2b4b06654caa
child 22	9d4d3445ce6e