1 /*

     2 * Copyright (c) 2006-2007 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:  Active object for an asynchronous thumbnail request

    15  *

    16 */

    17 

    18 

    19 #include <e32base.h>

    20 #include <hal.h>

    21 #include <hal_data.h>

    22 #include <apmstd.h>

    23 

    24 #include "thumbnailrequestactive.h"

    25 #include "thumbnailrequestqueue.h"

    26 #include "thumbnailsession.h"

    27 #include "thumbnailmanagerobserver.h"

    28 #include "thumbnailmanagerconstants.h"

    29 #include "thumbnaildataimpl.h"

    30 #include "thumbnailpanic.h"

    31 #include "thumbnaillog.h"

    32 

    33 #include "thumbnailmanagerimpl.h"

    34 #include "OstTraceDefinitions.h"

    35 #ifdef OST_TRACE_COMPILER_IN_USE

    36 #include "thumbnailrequestactiveTraces.h"

    37 #endif

    38 

    39 

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

    41 

    42 // ---------------------------------------------------------------------------

    43 // CThumbnailRequestActive::~CThumbnailRequestActive()

    44 // Destructor.

    45 // ---------------------------------------------------------------------------

    46 //

    47 CThumbnailRequestActive::~CThumbnailRequestActive()

    48     {

    49     Cancel();

    50     

    51     if(iTimer)

    52         {

    53         iTimer->Cancel();

    54         }

    55     

    56     delete iTimer;

    57     iTimer = NULL;

    58     

    59     ReleaseServerBitmap();

    60     delete iCallbackThumbnail;

    61     iCallbackThumbnail = NULL;

    62     delete iParams.iBuffer;

    63     iParams.iBuffer = NULL;

    64     delete iBitmap;

    65     iBitmap = NULL;

    66     iFile.Close();

    67     iMyFileHandle.Close();

    68     }

    69 

    70 

    71 // ---------------------------------------------------------------------------

    72 // CThumbnailRequestActive::NewL

    73 // Two-phased constructor.

    74 // ---------------------------------------------------------------------------

    75 //

    76 CThumbnailRequestActive* CThumbnailRequestActive::NewL( RFs& aFs,

    77     RThumbnailSession& aThumbnailSession, MThumbnailManagerObserver& aObserver,

    78     MThumbnailManagerRequestObserver* aRequestObserver,

    79     TThumbnailRequestId aId, TInt aPriority, CThumbnailRequestQueue* aQueue )

    80     {

    81     CThumbnailRequestActive* self = new( ELeave )CThumbnailRequestActive( aFs,

    82         aThumbnailSession, aObserver, aRequestObserver, aId, aPriority, aQueue );

    83     CleanupStack::PushL( self );

    84     self->ConstructL();

    85     CleanupStack::Pop( self );

    86     return self;

    87     }

    88 

    89 

    90 // ---------------------------------------------------------------------------

    91 // CThumbnailRequestActive::CThumbnailRequestActive()

    92 // C++ default constructor can NOT contain any code, that might leave.

    93 // ---------------------------------------------------------------------------

    94 //

    95 CThumbnailRequestActive::CThumbnailRequestActive( RFs& aFs, RThumbnailSession&

    96     aThumbnailSession, MThumbnailManagerObserver& aObserver,

    97     MThumbnailManagerRequestObserver* aRequestObserver,

    98     TThumbnailRequestId aId, TInt aPriority, CThumbnailRequestQueue* aQueue ):

    99     CActive( aPriority ), iSession( aThumbnailSession ), iParamsPckg( iParams ),

   100     iObserver( aObserver ), iRequestObserver( aRequestObserver ), iFs( aFs ), iBitmapHandle( 0 ), 

   101     iRequestId( aId ), iRequestQueue( aQueue ), iCanceled( EFalse )

   102 #ifdef __RETRY_ON_SERVERCRASH

   103     ,iRetry(0)

   104 #endif

   105     {

   106     CActiveScheduler::Add( this );

   107     TN_DEBUG2( "CThumbnaiRequestActive::CThumbnailRequestActive() AO's priority = %d", Priority());

   108     OstTrace1( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_CTHUMBNAILREQUESTACTIVE, "CThumbnailRequestActive::CThumbnailRequestActive - AO's priority;Priority()=%d", Priority() );

   109     

   110     iBitmap = NULL;

   111     iRequestCompleted = EFalse;

   112     }

   113 

   114 

   115 // ---------------------------------------------------------------------------

   116 // CThumbnailRequestActive::ConstructL()

   117 // Symbian 2nd phase constructor can leave.

   118 // ---------------------------------------------------------------------------

   119 //

   120 void CThumbnailRequestActive::ConstructL()

   121     {

   122     iCallbackThumbnail = new( ELeave )CThumbnailDataImpl();

   123 

   124     iTimer = CPeriodic::NewL(CActive::EPriorityIdle);

   125     iStartError = KErrNone;

   126     

   127 #ifdef _DEBUG

   128     iStartExecTime.UniversalTime();

   129 #endif

   130     }

   131 

   132 

   133 // ---------------------------------------------------------------------------

   134 // CThumbnailRequestActive::StartL()

   135 // Start active request.

   136 // ---------------------------------------------------------------------------

   137 //

   138 void CThumbnailRequestActive::StartL()

   139     {

   140     TN_DEBUG3( "CThumbnailRequestActive::StartL(0x%08x) reqid = %d", this, iRequestId );

   141     OstTrace1( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL;iRequestId=%u", iRequestId );

   142     

   143     iRequestActive = ETrue;

   144 

   145 #ifdef _DEBUG

   146     TTime stop;

   147     stop.UniversalTime();

   148     TN_DEBUG3( "CThumbnailRequestActive::StartL() req id = %d, queuing time %d ms",

   149                iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   150     OstTraceExt2( TRACE_NORMAL, DUP1_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL - req id = %d, queuing time %d ms",

   151                iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   152 #endif

   153     

   154     switch (iRequestType)

   155         {

   156         case EReqGetThumbnailHandle:

   157             {

   158             iSession.RequestThumbnailL( iFile, iTargetUri, iParamsPckg, iStatus );

   159             break;

   160             }        

   161         case EReqGetThumbnailPath:

   162             {

   163             // for custom size requests file handle can be opened here already, because

   164             // custom thumbnails are never stored in db  

   165             if (iParams.iThumbnailSize == ECustomThumbnailSize &&

   166                 iParams.iOriginalControlFlags != EThumbnailGeneratePersistentSizesOnly)

   167                 {

   168                 TN_DEBUG1( "CThumbnaiRequestActive::StartL()- custom size request" );

   169                 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL - custom size request" );

   170                   

   171                 iFile.Close();

   172                 User::LeaveIfError( iFile.Open( iFs, iPath, EFileShareReadersOrWriters ) );  

   173                 

   174                 TN_DEBUG2( "CThumbnailRequestActive::StartL() - file handle opened for %S", &iPath );

   175                 OstTraceExt1( TRACE_NORMAL, DUP3_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL;iPath=%S", iPath );

   176                 

   177                 CleanupClosePushL( iFile );

   178                 

   179                 if ( iParams.iQualityPreference == CThumbnailManager::EOptimizeForQualityWithPreview )

   180                     {

   181                     // We may need the file handle later for the 2nd phase thumbnail

   182                     iMyFileHandle.Close();

   183                     User::LeaveIfError( iMyFileHandle.Duplicate( iFile ));

   184                     }

   185                 

   186                 iSession.RequestThumbnailL( iFile, iPath, iParamsPckg, iStatus );

   187                 CleanupStack::PopAndDestroy( &iFile );   

   188                 }

   189             else

   190                 {

   191                 iSession.RequestThumbnailL( iPath, iTargetUri, iParams.iThumbnailId, 

   192                                             iParamsPckg, iStatus );

   193                 }            

   194             break;

   195             }  

   196         case EReqSetThumbnailBuffer:

   197             {

   198             iSession.RequestSetThumbnailL( iParams.iBuffer, iTargetUri, iParamsPckg, iStatus );

   199             break;

   200             }  

   201         case EReqSetThumbnailBitmap:

   202             {

   203             iSession.RequestSetThumbnailL( iBitmap->Handle(), iTargetUri, iParamsPckg, iStatus );

   204             break;

   205             }  

   206         case EReqUpdateThumbnails:

   207             {

   208             iSession.UpdateThumbnails( iPath, iOrientation, iModified, iParamsPckg, iStatus );

   209             break;

   210             }       

   211         case EReqGetThumbnailHandleLater:

   212             {

   213             // open file handle

   214             iFile.Close();

   215             User::LeaveIfError( iFile.Open( iFs, iTargetUri, EFileShareReadersOrWriters ) );  

   216             

   217             TN_DEBUG2( "CThumbnailRequestActive::StartL() - file handle opened for %S", &iTargetUri );

   218             OstTraceExt1( TRACE_NORMAL, DUP4_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL - file handle opened;iTargetUri=%S", iTargetUri );

   219             

   220             CleanupClosePushL( iFile );

   221             

   222             if ( iParams.iQualityPreference == CThumbnailManager::EOptimizeForQualityWithPreview )

   223                 {

   224                 // We may need the file handle later for the 2nd phase thumbnail

   225                 iMyFileHandle.Close();

   226                 User::LeaveIfError( iMyFileHandle.Duplicate( iFile ));

   227                 }

   228             

   229             iSession.RequestThumbnailL( iFile, iTargetUri, iParamsPckg, iStatus );

   230             CleanupStack::PopAndDestroy( &iFile );

   231             break;

   232             }  

   233         case EReqDeleteThumbnails:

   234             {

   235             // by path

   236             if (iPath != KNullDesC)

   237                 {

   238                 iSession.DeleteThumbnails( iPath, iParamsPckg, iStatus );

   239                 }

   240             // by id

   241             else

   242                 {

   243                 iSession.DeleteThumbnails( iParams.iThumbnailId, iParamsPckg, iStatus );

   244                 }

   245             break;

   246             }

   247         case EReqRenameThumbnails:

   248             {

   249             iSession.RenameThumbnails( iParamsPckg, iStatus );

   250             break;

   251             }  

   252         case EReqSetThumbnailPath:

   253             {

   254             // open file handle

   255             iFile.Close();

   256             User::LeaveIfError( iFile.Open( iFs, iParams.iFileName, EFileShareReadersOrWriters ) );  

   257             

   258             TN_DEBUG2( "CThumbnailRequestActive::StartL() - file handle opened for %S", &iParams.iFileName );

   259             OstTraceExt1( TRACE_NORMAL, DUP5_CTHUMBNAILREQUESTACTIVE_STARTL, "CThumbnailRequestActive::StartL;iParams.iFileName=%S", iParams.iFileName );

   260             

   261             CleanupClosePushL( iFile );

   262             

   263             if ( iParams.iQualityPreference == CThumbnailManager::EOptimizeForQualityWithPreview )

   264                 {

   265                 // We may need the file handle later for the 2nd phase thumbnail

   266                 iMyFileHandle.Close();

   267                 User::LeaveIfError( iMyFileHandle.Duplicate( iFile ));

   268                 }

   269             

   270             iSession.RequestThumbnailL( iFile, iTargetUri, iParamsPckg, iStatus );

   271             CleanupStack::PopAndDestroy( &iFile );

   272 

   273             break;

   274             } 

   275             

   276         default:

   277             {

   278             break;

   279             }

   280         }

   281     

   282     iTimer->Cancel();

   283     iTimer->Start( KClientRequestTimeout, KClientRequestTimeout, 

   284                    TCallBack(TimerCallBack, this));

   285     SetActive();

   286     }

   287 

   288 

   289 // ---------------------------------------------------------------------------

   290 // CThumbnailRequestActive::RunL()

   291 // ---------------------------------------------------------------------------

   292 //

   293 void CThumbnailRequestActive::RunL()

   294     {

   295     TN_DEBUG2( "CThumbnailRequestActive::RunL() - request ID: %d", iParams.iRequestId );

   296     OstTrace1( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u", iParams.iRequestId );

   297  

   298     if ( iParams.iControlFlags == EThumbnailPreviewThumbnail )

   299         {

   300         iRequestCompleted = EFalse;

   301 		iProcessingPreview = ETrue;

   302         }

   303     else

   304         {

   305         iRequestCompleted = ETrue;

   306         }

   307     

   308     iTimer->Cancel();

   309     

   310     if (iRequestType == EReqDeleteThumbnails)

   311         {

   312         TN_DEBUG1( "CThumbnailRequestActive::RunL() - delete" );

   313     

   314         if (iRequestObserver)

   315             {

   316             iRequestObserver->ThumbnailRequestReady(iStatus.Int(), ERequestDeleteThumbnails ,iParams.iRequestId);

   317             }

   318         

   319         iFile.Close();

   320         iMyFileHandle.Close();

   321     

   322         // no action for delete/rename or canceled request

   323         iRequestQueue->RequestComplete(this);

   324         

   325 #ifdef _DEBUG

   326     TTime stop;

   327     stop.UniversalTime();

   328     TN_DEBUG3( "CThumbnailRequestActive::RunL() total execution time of req %d is %d ms",

   329                 iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   330     OstTraceExt2( TRACE_NORMAL, DUP1_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - total execution time of req %d is %d ms",

   331                 iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   332 #endif

   333         }

   334     else if (iCanceled || iRequestType == EReqRenameThumbnails)

   335         {

   336         if (iCanceled)

   337             {

   338             TN_DEBUG1( "CThumbnailRequestActive::RunL() - canceled" );

   339             }

   340         else if (iRequestType == EReqRenameThumbnails)

   341             {

   342             TN_DEBUG1( "CThumbnailRequestActive::RunL() - rename" );

   343             }

   344     

   345         iFile.Close();

   346         iMyFileHandle.Close();

   347     

   348         // no action for delete/rename or canceled request

   349         iRequestQueue->RequestComplete(this);

   350         

   351 #ifdef _DEBUG

   352     TTime stop;

   353     stop.UniversalTime();

   354     TN_DEBUG3( "CThumbnailRequestActive::RunL() total execution time of req %d is %d ms",

   355                 iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   356     OstTraceExt2( TRACE_NORMAL, DUP2_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - total execution time of req %d is %d ms",

   357                 iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   358 #endif

   359         }

   360     else if ( iStatus.Int() == KThumbnailErrThumbnailNotFound && iParams.iFileName.Length() && 

   361          !( iParams.iFlags& CThumbnailManager::EDoNotCreate ))

   362         {

   363         TN_DEBUG2( "CThumbnaiRequestActive::RunL() - no thumbnail found - lets try with file handle %S", &iParams.iFileName );

   364         OstTraceExt1( TRACE_NORMAL, DUP3_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - no thumbnail found - lets try with file handle;iParams.iFileName=%S", iParams.iFileName );

   365         iRequestCompleted = EFalse;

   366         

   367         // We tried to get thumbnail using file path, but it was not found in

   368         // the database. We need to open the file now (on the client side) and

   369         // use file handle.     

   370         iFile.Close();

   371         TInt err = iFile.Open( iFs, iParams.iFileName, EFileShareReadersOrWriters );

   372         TN_DEBUG2( "CThumbnaiRequestActive::RunL() - file handle open err = %d", err );

   373         OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - file handle open err;err=%d", err );

   374         User::LeaveIfError( err );

   375         

   376         CleanupClosePushL( iFile );

   377         

   378         TN_DEBUG2( "CThumbnaiRequestActive::RunL() - file handle opened for %S", &iParams.iFileName );

   379         OstTraceExt1( TRACE_NORMAL, DUP5_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iFileName=%S", iParams.iFileName );

   380         

   381         iSession.RequestThumbnailL( iFile, iParams.iFileName, iParamsPckg, iStatus );

   382         CleanupStack::PopAndDestroy( &iFile );

   383         

   384         iTimer->Start( KClientRequestTimeout, KClientRequestTimeout, 

   385                            TCallBack(TimerCallBack, this));

   386         SetActive();

   387         }

   388     else if ( iStatus.Int() )

   389         {

   390         TN_DEBUG2( "CThumbnailRequestActive::RunL() - error (%d) occured", iStatus.Int() );

   391         // An error occurred

   392         iError = iStatus.Int();

   393         HandleError();

   394         }

   395     //1st round thumb ready from exif (stored)

   396     else if (iParams.iOriginalControlFlags == EThumbnailGeneratePersistentSizesOnly && !iProcessingPreview)

   397 	    {

   398 	    TN_DEBUG1( "CThumbnaiRequestActive::RunL()- generate persistent sizes thumbnailready" );

   399 	    OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - generate persistent sizes thumbnailready" );

   400 	    iBitmapHandle = iParams.iBitmapHandle;

   401 	    

   402 	    TN_DEBUG2( "CThumbnaiRequestActive::RunL() - iObserver.ThumbnailReady %d", iParams.iRequestId );

   403 	    OstTrace1( TRACE_NORMAL, DUP7_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u", iParams.iRequestId );

   404 	    iObserver.ThumbnailReady( iStatus.Int(), *iCallbackThumbnail, iParams.iRequestId );

   405 	  

   406 	    ReleaseServerBitmap();

   407 	    

   408 	    iFile.Close();

   409 	    iMyFileHandle.Close();

   410 	    

   411 	    iRequestQueue->RequestComplete(this);

   412 	    

   413         #ifdef _DEBUG

   414             TTime stop;

   415             stop.UniversalTime();

   416             TN_DEBUG3( "CThumbnailRequestActive::RunL() total execution time %d, %d ms",

   417                        iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   418             OstTraceExt2( TRACE_NORMAL, DUP8_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - total execution time %d, %d ms",

   419                        iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   420             

   421         #endif

   422 	    }

   423     //1st round preview ready from too low quality exif/exif not found (not-stored)

   424     //relauch using normal decoding

   425     else if (iParams.iOriginalControlFlags == EThumbnailGeneratePersistentSizesOnly && iProcessingPreview)

   426         {

   427         TN_DEBUG1( "CThumbnaiRequestActive::RunL()- generate persistent sizes thumbnailpreviewready" );

   428         OstTrace0( TRACE_NORMAL, DUP9_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - generate persistent sizes thumbnailpreviewready" );

   429         iBitmapHandle = iParams.iBitmapHandle;

   430         

   431         TN_DEBUG2( "CThumbnaiRequestActive::RunL() - iObserver.ThumbnailPreviewReady %d", iParams.iRequestId );

   432         OstTrace1( TRACE_NORMAL, DUP10_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u", iParams.iRequestId );

   433         iObserver.ThumbnailPreviewReady( *iCallbackThumbnail, iParams.iRequestId );

   434         

   435         iProcessingPreview = EFalse;

   436       

   437         ReleaseServerBitmap();

   438         

   439         iFile.Close();

   440         

   441         //set flags so that EThumbnailGeneratePersistentSizesOnly is done aka check all missing sizes 

   442         iParams.iQualityPreference = CThumbnailManager::EOptimizeForQuality;

   443         iParams.iControlFlags = EThumbnailGeneratePersistentSizesOnly;

   444         iRequestType = EReqUpdateThumbnails;

   445         

   446         //increase priority

   447         this->SetPriority(this->Priority() + 1);

   448         iParams.iPriority++;

   449         

   450         iSession.UpdateThumbnails( iPath, iOrientation, iModified, iParamsPckg, iStatus );

   451         

   452         SetActive();

   453            

   454     	#ifdef _DEBUG

   455         TTime stop;

   456         stop.UniversalTime();

   457         TN_DEBUG3( "CThumbnailRequestActive::RunL() total execution time %d, %d ms",

   458                    iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   459     	#endif

   460         }

   461     else

   462         {

   463         TN_DEBUG1( "CThumbnailRequestActive::RunL() - succesful" );

   464         OstTrace0( TRACE_NORMAL, DUP11_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - succesful" );

   465         

   466         // Success

   467         iBitmapHandle = iParams.iBitmapHandle;

   468         

   469         if( iBitmapHandle )

   470             {

   471             CFbsBitmap* bitmap = new( ELeave )CFbsBitmap();

   472             CleanupStack::PushL( bitmap );

   473             User::LeaveIfError( bitmap->Duplicate( iBitmapHandle ));

   474             CleanupStack::Pop( bitmap );

   475             

   476             // reduce bpp value (displaymode to match reqested bits per pixel)

   477             #ifdef _DEBUG

   478             TN_DEBUG2( "CThumbnailRequestActive::RunL() - displaymode is %d", bitmap->DisplayMode());

   479             OstTrace1( TRACE_NORMAL, DUP12_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;bitmap->DisplayMode()=%u", bitmap->DisplayMode() );

   480             #endif

   481             

   482             if( bitmap->DisplayMode() > iParams.iDisplayMode )

   483                 {

   484                 bitmap->SetDisplayMode( iParams.iDisplayMode );

   485                 #ifdef _DEBUG

   486                 TN_DEBUG2( "CThumbnailRequestActive::RunL() - displaymode is now %d", bitmap->DisplayMode());

   487                 OstTrace1( TRACE_NORMAL, DUP13_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;bitmap->DisplayMode()=%u", bitmap->DisplayMode() );

   488                 #endif

   489                 }

   490             

   491             iCallbackThumbnail->Set( bitmap, iClientData );

   492             bitmap = NULL; // Owned by iCallbackThumbnail or client now

   493             }

   494 

   495         if ( iProcessingPreview )

   496             {

   497             TN_DEBUG2( "CThumbnailRequestActive::RunL() - iObserver.ThumbnailPreviewReady %d", iParams.iRequestId );

   498 			OstTrace1( TRACE_NORMAL, DUP14_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL - iObserver.ThumbnailPreviewReady;iParams.iRequestId=%u", iParams.iRequestId );

   499 			

   500             //increase priority of 2nd round (both, AO and request itself)

   501             this->SetPriority(this->Priority() + 1);

   502             iParams.iPriority++;

   503             iObserver.ThumbnailPreviewReady( *iCallbackThumbnail, iParams.iRequestId );

   504             iProcessingPreview = EFalse;

   505             

   506             ReleaseServerBitmap();

   507             

   508             iFile.Close();

   509             

   510             Get2ndPhaseThumbnailL();

   511             }

   512         else

   513             {

   514             TN_DEBUG2( "CThumbnailRequestActive::RunL() - iObserver.ThumbnailReady %d", iParams.iRequestId );

   515             OstTrace1( TRACE_NORMAL, DUP15_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u", iParams.iRequestId );

   516             

   517             iObserver.ThumbnailReady( iStatus.Int(), * iCallbackThumbnail, iParams.iRequestId );

   518             ReleaseServerBitmap();    

   519             

   520             iFile.Close();

   521             iMyFileHandle.Close();

   522             

   523             iRequestQueue->RequestComplete(this);

   524             

   525 #ifdef _DEBUG

   526         TTime stop;

   527         stop.UniversalTime();

   528         TInt tookTime = (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000;

   529         TN_DEBUG4( "CThumbnailRequestActive::RunL(0x%08x) total execution time of req %d is %d ms",

   530                 this, iParams.iRequestId, (TInt)stop.MicroSecondsFrom(iStartExecTime).Int64()/1000 );

   531         OstTrace1( TRACE_NORMAL, DUP16_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;this=%o", this );

   532         OstTraceExt2( TRACE_NORMAL, DUP17_CTHUMBNAILREQUESTACTIVE_RUNL, "CThumbnailRequestActive::RunL;iParams.iRequestId=%u;tookTime=%d", iParams.iRequestId, tookTime );

   533 #endif

   534             }

   535         }

   536     

   537     delete iBitmap;

   538     iBitmap = NULL;

   539     

   540     //if request is complete set it also not active -> really finished

   541     if(iRequestCompleted)

   542         {

   543         iRequestActive = EFalse;

   544         }

   545     }

   546 

   547 

   548 // ---------------------------------------------------------------------------

   549 // CThumbnailRequestActive::RunError()

   550 // ---------------------------------------------------------------------------

   551 //

   552 TInt CThumbnailRequestActive::RunError( TInt aError )

   553     {

   554     TN_DEBUG1( "CThumbnailRequestActive::RunError");

   555     OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_RUNERROR, "CThumbnailRequestActive::RunError" );

   556     

   557     iTimer->Cancel();

   558     

   559     // If RunL() left, the client did not get any callbacks yet.

   560     // We need to notify it of the error now.

   561     iError = aError;

   562     HandleError();

   563     

   564     return KErrNone;

   565     }

   566 

   567 

   568 // ---------------------------------------------------------------------------

   569 // CThumbnailRequestActive::DoCancel()

   570 // ---------------------------------------------------------------------------

   571 //

   572 void CThumbnailRequestActive::DoCancel()

   573     {

   574     TN_DEBUG1( "CThumbnailRequestActive::DoCancel");

   575     OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_DOCANCEL, "CThumbnailRequestActive::DoCancel" );

   576     iTimer->Cancel();

   577     

   578     __ASSERT_DEBUG(( iRequestId > 0 ), ThumbnailPanic( EThumbnailWrongId ));

   579 

   580     iCanceled = ETrue;

   581     iSession.CancelRequest( iRequestId );

   582     ReleaseServerBitmap();

   583     }

   584 

   585 

   586 // ---------------------------------------------------------------------------

   587 // CThumbnailRequestActive::AsyncCancel()

   588 // ---------------------------------------------------------------------------

   589 //

   590 void CThumbnailRequestActive::AsyncCancel()

   591     {

   592     TN_DEBUG1( "CThumbnailRequestActive::AsyncCancel");

   593     OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_ASYNCCANCEL, "CThumbnailRequestActive::AsyncCancel" );

   594 

   595     __ASSERT_DEBUG(( iRequestId > 0 ), ThumbnailPanic( EThumbnailWrongId ));

   596     

   597     iCanceled = ETrue;

   598     iSession.CancelRequest( iRequestId );

   599     ReleaseServerBitmap();

   600 

   601     // AO stays active until request is complete or timeout is reached

   602     }

   603 

   604 

   605 // ---------------------------------------------------------------------------

   606 // CThumbnailRequestActive::ReleaseServerBitmap()

   607 // Releases reserved bitmap.

   608 // ---------------------------------------------------------------------------

   609 //

   610 void CThumbnailRequestActive::ReleaseServerBitmap()

   611     {

   612     if ( iBitmapHandle && iSession.Handle())

   613         {

   614     	TN_DEBUG1( "CThumbnailRequestActive::ReleaseServerBitmap");

   615     	OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_RELEASESERVERBITMAP, "CThumbnailRequestActive::ReleaseServerBitmap" );

   616     

   617         iSession.ReleaseBitmap( iBitmapHandle );

   618         iBitmapHandle = 0;

   619         }

   620     }

   621 

   622 

   623 // ---------------------------------------------------------------------------

   624 // CThumbnailRequestActive::HandleError()

   625 // Error handling function.

   626 // ---------------------------------------------------------------------------

   627 //

   628 void CThumbnailRequestActive::HandleError()

   629     {

   630     TN_DEBUG1( "CThumbnailRequestActive::HandleError");

   631     OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError" );

   632     

   633     if ( iError )

   634         {

   635         if( iError == KErrServerTerminated)

   636             {

   637             iSession.Close();

   638             TInt connErr = iSession.Connect();

   639             if (connErr != KErrNone)

   640                 {

   641                 TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - session reconnect err %d", connErr );

   642                 OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError;err=%d", connErr );

   643                 }

   644             else

   645                 {

   646                 TN_DEBUG1( "CThumbnailRequestActive::HandleError() - session reconnected");

   647                 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError - session reconnected" );

   648                 }

   649             }

   650 

   651         if (iRequestObserver && iRequestType == EReqDeleteThumbnails)

   652              {

   653              TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - iRequestObserver->ThumbnailRequestReady %d", iParams.iRequestId );

   654              OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError;iParams.iRequestId=%u", iParams.iRequestId );

   655              iRequestObserver->ThumbnailRequestReady(iError, ERequestDeleteThumbnails ,iParams.iRequestId);

   656              }

   657         else

   658             {			

   659 			 iCallbackThumbnail->Set( NULL, iClientData );

   660         

   661 	        // don't leak internal TNM codes

   662 	        if (iError == KThumbnailErrThumbnailNotFound)

   663 	            {

   664 	            iError = KErrNotFound;

   665 	            }

   666 	        

   667 #ifdef __RETRY_ON_SERVERCRASH

   668 	        if(iError == KErrServerTerminated )

   669 	            {

   670                   

   671                 if(iRetry < KMaxRequestRetryCount )

   672                     {

   673                     iRetry++;

   674                     TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - KErrServerTerminated, retry %d", iRetry);

   675                     OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError - KErrServerTerminated;iRetry=%d", iRetry );

   676                     iError = KErrNone;

   677                     TRAPD(err, StartL());

   678                     return;

   679                     }

   680 	            }

   681 #endif

   682 	        TN_DEBUG3( "CThumbnaiRequestActive::HandleError() - iObserver.ThumbnailReady req=%d err=%d", iParams.iRequestId, iError );

   683 	        OstTrace1( TRACE_NORMAL, DUP5_CTHUMBNAILREQUESTACTIVE_HANDLEERROR, "CThumbnailRequestActive::HandleError - iObserver.ThumbnailReady %u", iParams.iRequestId );

   684 	        iObserver.ThumbnailReady( iError, *iCallbackThumbnail, iParams.iRequestId );

   685 	            

   686             }

   687         

   688         iError = KErrNone;

   689         }

   690     

   691     ReleaseServerBitmap();

   692     

   693     iFile.Close();

   694     iMyFileHandle.Close();

   695     

   696     iRequestCompleted = ETrue;

   697     iRequestQueue->RequestComplete(this);

   698     iRequestActive = EFalse;

   699     }

   700 

   701 

   702 // ---------------------------------------------------------------------------

   703 // CThumbnailRequestActive::GetThumbnailL()

   704 // Get a thumbnail for an object file.

   705 // ---------------------------------------------------------------------------

   706 //

   707 void CThumbnailRequestActive::GetThumbnailL( const RFile64& aFile, TThumbnailId aThumbnailId,

   708     const TDesC8& aMimeType, CThumbnailManager::TThumbnailFlags aFlags, CThumbnailManager

   709     ::TThumbnailQualityPreference aQualityPreference, const TSize& aSize, const

   710     TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData, TBool aGeneratePersistentSizesOnly,

   711     const TDesC& aTargetUri, TThumbnailSize aThumbnailSize)

   712     {

   713     iRequestType = EReqGetThumbnailHandle;

   714 

   715     if ( aQualityPreference == CThumbnailManager

   716         ::EOptimizeForQualityWithPreview )

   717         {

   718         // We may need the file handle later for the 2nd phase

   719         // thumbnail

   720         iMyFileHandle.Close();

   721         User::LeaveIfError( iMyFileHandle.Duplicate( aFile ));

   722         }

   723 

   724     iClientData = aClientData;

   725     iParams.iControlFlags = (aGeneratePersistentSizesOnly ?

   726     						EThumbnailGeneratePersistentSizesOnly :

   727     						EThumbnailNoControlFlags);    

   728     iParams.iOriginalControlFlags = iParams.iControlFlags;

   729     iParams.iMimeType = TDataType( aMimeType );

   730     iParams.iBitmapHandle = 0;

   731     iParams.iSize = aSize;

   732     iParams.iDisplayMode = aDisplayMode;

   733     User::LeaveIfError( aFile.FullName( iParams.iFileName ));

   734     iParams.iRequestId = iRequestId;

   735     iParams.iPriority = aPriority;

   736     iParams.iFlags = aFlags;

   737     iParams.iQualityPreference = aQualityPreference;

   738     iParams.iThumbnailSize = aThumbnailSize;

   739     iParams.iThumbnailId = aThumbnailId;

   740     iParams.iOverwrite = EFalse;

   741     iParams.iImport = EFalse;

   742     

   743     User::LeaveIfError( iFile.Duplicate( aFile ));

   744     

   745     iTargetUri = aTargetUri;

   746     

   747     if (iParams.iFileName.Length() && IsVirtualUri(iParams.iFileName))

   748         {

   749         iParams.iVirtualUri = ETrue;

   750         }

   751     else

   752         {

   753         iParams.iVirtualUri = EFalse;

   754         }

   755     }

   756 

   757 

   758 // ---------------------------------------------------------------------------

   759 // CThumbnailRequestActive::GetThumbnailL()

   760 // Get a thumbnail opening an object file later.

   761 // ---------------------------------------------------------------------------

   762 //

   763 void CThumbnailRequestActive::GetThumbnailL( TThumbnailId aThumbnailId,

   764     const TDesC& aPath, const TDesC8& aMimeType, CThumbnailManager::TThumbnailFlags aFlags, 

   765     CThumbnailManager::TThumbnailQualityPreference aQualityPreference, const TSize& aSize, const

   766     TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData, TBool aGeneratePersistentSizesOnly,

   767     const TDesC& aTargetUri, TThumbnailSize aThumbnailSize)

   768     {

   769     iRequestType = EReqGetThumbnailHandleLater;

   770 

   771     iClientData = aClientData;

   772     iParams.iControlFlags = (aGeneratePersistentSizesOnly ?

   773                             EThumbnailGeneratePersistentSizesOnly :

   774                             EThumbnailNoControlFlags);

   775     iParams.iOriginalControlFlags = iParams.iControlFlags;

   776     iParams.iMimeType = TDataType( aMimeType );

   777     iParams.iBitmapHandle = 0;

   778     iParams.iSize = aSize;

   779     iParams.iDisplayMode = aDisplayMode;

   780     iParams.iFileName = aPath;

   781     iParams.iRequestId = iRequestId;

   782     iParams.iPriority = aPriority;

   783     iParams.iFlags = aFlags;

   784     iParams.iQualityPreference = aQualityPreference;

   785     iParams.iThumbnailSize = aThumbnailSize;

   786     iParams.iThumbnailId = aThumbnailId;

   787     iParams.iOverwrite = EFalse;

   788     iParams.iImport = EFalse;

   789     

   790     iTargetUri = aTargetUri;

   791     

   792     if (iPath.Length() && IsVirtualUri(iPath))

   793         {

   794         iParams.iVirtualUri = ETrue;

   795         }

   796     else

   797         {

   798         iParams.iVirtualUri = EFalse;

   799         }

   800     }

   801 

   802 

   803 // ---------------------------------------------------------------------------

   804 // CThumbnailRequestActive::GetThumbnailL()

   805 // Get a thumbnail for an object file.

   806 // ---------------------------------------------------------------------------

   807 //

   808 void CThumbnailRequestActive::GetThumbnailL( const TDesC& aPath, TThumbnailId aThumbnailId,

   809     const TDesC8& aMimeType, CThumbnailManager::TThumbnailFlags aFlags, CThumbnailManager

   810     ::TThumbnailQualityPreference aQualityPreference, const TSize& aSize, const

   811     TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData, TBool aGeneratePersistentSizesOnly,

   812     const TDesC& aTargetUri, TThumbnailSize aThumbnailSize)

   813     {

   814     iRequestType = EReqGetThumbnailPath;

   815 

   816     iClientData = aClientData;

   817     iParams.iControlFlags = (aGeneratePersistentSizesOnly ?

   818     						EThumbnailGeneratePersistentSizesOnly :

   819     						EThumbnailNoControlFlags);

   820     iParams.iOriginalControlFlags = iParams.iControlFlags;

   821     iParams.iMimeType = TDataType( aMimeType );

   822     iParams.iBitmapHandle = 0;

   823     iParams.iSize = aSize;

   824     iParams.iDisplayMode = aDisplayMode;

   825     iParams.iRequestId = iRequestId;

   826     iParams.iPriority = aPriority;

   827     iParams.iFlags = aFlags;

   828     iParams.iQualityPreference = aQualityPreference;

   829     iParams.iThumbnailSize = aThumbnailSize;

   830     iParams.iThumbnailId = aThumbnailId;

   831     iParams.iFileName = aPath;

   832     iParams.iOverwrite = EFalse;

   833     iParams.iImport = EFalse;

   834     

   835     iPath = aPath;

   836     iTargetUri = aTargetUri;

   837     

   838     if (iPath.Length() && IsVirtualUri(iPath))

   839         {

   840         iParams.iVirtualUri = ETrue;

   841         }

   842     else

   843         {

   844         iParams.iVirtualUri = EFalse;

   845         }

   846     }

   847 

   848 // ---------------------------------------------------------------------------

   849 // CThumbnailRequestActive::SetThumbnailL()

   850 // Get a thumbnail for an object file.

   851 // ---------------------------------------------------------------------------

   852 //

   853 void CThumbnailRequestActive::SetThumbnailL( TDesC8* aBuffer, TThumbnailId aThumbnailId,

   854     const TDesC8& aMimeType, CThumbnailManager::TThumbnailFlags aFlags,

   855     CThumbnailManager::TThumbnailQualityPreference aQualityPreference, const TSize& aSize,

   856     const TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData,

   857     TBool aGeneratePersistentSizesOnly, const TDesC& aTargetUri, TThumbnailSize aThumbnailSize,

   858     TBool aOverwrite)

   859     {

   860     iRequestType = EReqSetThumbnailBuffer;

   861 

   862     iClientData = aClientData;

   863     iParams.iControlFlags = (aGeneratePersistentSizesOnly ?

   864                             EThumbnailGeneratePersistentSizesOnly :

   865                             EThumbnailNoControlFlags);

   866     iParams.iOriginalControlFlags = iParams.iControlFlags;  

   867     iParams.iMimeType = TDataType( aMimeType );

   868     iParams.iBitmapHandle = 0;

   869     iParams.iSize = aSize;

   870     iParams.iBuffer = aBuffer; // save pointer for deletion (~CThumbnailRequestActive())

   871     iParams.iThumbnailSize = aThumbnailSize;

   872     iParams.iDisplayMode = aDisplayMode;

   873     iParams.iRequestId = iRequestId;

   874     iParams.iPriority = aPriority;

   875     iParams.iFlags = aFlags;

   876     iParams.iQualityPreference = aQualityPreference;

   877     iParams.iThumbnailId = aThumbnailId;

   878     iParams.iOverwrite = aOverwrite;

   879     iParams.iImport = EFalse;

   880     

   881     iTargetUri = aTargetUri;

   882     

   883     if (iTargetUri.Length() && IsVirtualUri(iTargetUri))

   884         {

   885         iParams.iVirtualUri = ETrue;

   886         }

   887     else

   888         {

   889         iParams.iVirtualUri = EFalse;

   890         }

   891     }

   892 

   893 // ---------------------------------------------------------------------------

   894 // CThumbnailRequestActive::SetThumbnailL()

   895 // Get a thumbnail for an object file.

   896 // ---------------------------------------------------------------------------

   897 //

   898 void CThumbnailRequestActive::SetThumbnailL( CFbsBitmap* aBitmap, TThumbnailId aThumbnailId,

   899     const TDesC8& aMimeType, CThumbnailManager::TThumbnailFlags aFlags,

   900     CThumbnailManager::TThumbnailQualityPreference aQualityPreference, const TSize& aSize,

   901     const TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData,

   902     TBool aGeneratePersistentSizesOnly, const TDesC& aTargetUri, TThumbnailSize aThumbnailSize,

   903     TBool aOverwrite)

   904     {    

   905     iClientData = aClientData;

   906     iParams.iControlFlags = (aGeneratePersistentSizesOnly ?

   907                             EThumbnailGeneratePersistentSizesOnly :

   908                             EThumbnailNoControlFlags);

   909     iParams.iOriginalControlFlags = iParams.iControlFlags;  

   910     iParams.iBitmapHandle = 0;

   911     iParams.iSize = aSize;

   912     iParams.iThumbnailSize = aThumbnailSize;

   913     iParams.iDisplayMode = aDisplayMode;

   914     iParams.iRequestId = iRequestId;

   915     iParams.iPriority = aPriority;

   916     iParams.iFlags = aFlags;

   917     iParams.iQualityPreference = aQualityPreference;

   918     iParams.iThumbnailId = aThumbnailId;

   919     iParams.iFileName = aTargetUri;

   920     iParams.iOverwrite = aOverwrite;

   921     iParams.iImport = EFalse;

   922     

   923     iTargetUri = aTargetUri;

   924     

   925     if (iTargetUri.Length() && IsVirtualUri(iTargetUri))

   926         {

   927         iParams.iVirtualUri = ETrue;

   928         }

   929     else

   930         {

   931         iParams.iVirtualUri = EFalse;

   932         }

   933     

   934     TInt memoryFree( 0 );

   935     HAL::Get( HALData::EMemoryRAMFree, memoryFree );

   936     

   937     TN_DEBUG2( "CThumbnaiRequestActive::SetThumbnailbyBitmap() - memoryFree %d", memoryFree );

   938     

   939     if(memoryFree > KMemoryNeed)

   940         {

   941         // save parameter bitmap, it will be deleted when request is complete

   942         iBitmap = aBitmap;                   

   943         iParams.iMimeType = TDataType( aMimeType );

   944         iRequestType = EReqSetThumbnailBitmap;

   945         }

   946     else if (!iParams.iVirtualUri)

   947         {

   948         // memory low, create thumbs using filehandle

   949         TN_DEBUG1( "CThumbnaiRequestActive::SetThumbnailbyBitmap() - memory low, create thumbs using filehandle!" );

   950         OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_SETTHUMBNAILL, "CThumbnailRequestActive::SetThumbnailL - memory low, create thumbs using filehandle!" );

   951         delete aBitmap;

   952         aBitmap = NULL;

   953         iParams.iPriority = aPriority - 1;

   954         iRequestType = EReqGetThumbnailHandleLater;

   955         }

   956     else

   957         {

   958         User::Leave(KErrNoMemory);

   959         }

   960     }

   961 

   962 // ---------------------------------------------------------------------------

   963 // CThumbnailRequestActive::UpdateThumbnailsL()

   964 // Update thumbnails by Id.

   965 // ---------------------------------------------------------------------------

   966 //

   967 void CThumbnailRequestActive::UpdateThumbnailsL( const TDesC& aPath, 

   968     const TThumbnailId aThumbnailId, CThumbnailManager::TThumbnailFlags aFlags, 

   969     CThumbnailManager::TThumbnailQualityPreference aQualityPreference, 

   970     const TDisplayMode aDisplayMode, const TInt aPriority, const TInt aOrientation,

   971     const TInt64 aModified )

   972     {

   973     iRequestType = EReqUpdateThumbnails;

   974     

   975     iParams.iControlFlags = EThumbnailGeneratePersistentSizesOnly;   

   976     iParams.iOriginalControlFlags = iParams.iControlFlags;

   977     iParams.iBitmapHandle = 0;

   978     iParams.iDisplayMode = aDisplayMode;

   979     iParams.iRequestId = iRequestId;

   980     iParams.iPriority = aPriority;

   981     iParams.iFlags = aFlags;

   982     iParams.iQualityPreference = aQualityPreference;

   983     iParams.iThumbnailId = aThumbnailId;

   984     iParams.iOverwrite = EFalse;

   985     iParams.iVirtualUri = EFalse;

   986     iParams.iImport = EFalse;

   987     

   988     iPath = aPath;

   989     iOrientation = aOrientation;

   990     iModified = aModified;

   991     }

   992 

   993 // ---------------------------------------------------------------------------

   994 // CThumbnailRequestActive::DeleteThumbnails()

   995 // Delete thumbnails.

   996 // ---------------------------------------------------------------------------

   997 //

   998 void CThumbnailRequestActive::DeleteThumbnails( const TDesC& aPath, 

   999     const TThumbnailId aThumbnailId, const TInt aPriority )

  1000     {

  1001     iRequestType = EReqDeleteThumbnails;

  1002     

  1003     iParams.iRequestId = iRequestId;

  1004     iParams.iPriority = aPriority;

  1005     iParams.iThumbnailId = aThumbnailId;

  1006     

  1007     iPath = aPath;

  1008     }

  1009 

  1010 // ---------------------------------------------------------------------------

  1011 // CThumbnailRequestActive::RenameThumbnails()

  1012 // Rename thumbnails.

  1013 // ---------------------------------------------------------------------------

  1014 //

  1015 void CThumbnailRequestActive::RenameThumbnails( const TDesC& aCurrentPath, 

  1016         const TDesC& aNewPath, const TInt aPriority )

  1017     {

  1018     iRequestType = EReqRenameThumbnails;

  1019     

  1020     iParams.iRequestId = iRequestId;

  1021     iParams.iPriority = aPriority;

  1022     iParams.iFileName = aCurrentPath;

  1023     iParams.iTargetUri = aNewPath;

  1024     }

  1025 

  1026 // ---------------------------------------------------------------------------

  1027 // CThumbnailRequestActive::SetThumbnailL()

  1028 // Set thumbnail from file path.

  1029 // ---------------------------------------------------------------------------

  1030 //

  1031 void CThumbnailRequestActive::SetThumbnailL( const TDesC& aPath, const TDesC8& aMimeType,

  1032     CThumbnailManager::TThumbnailFlags aFlags, CThumbnailManager

  1033     ::TThumbnailQualityPreference aQualityPreference, const TSize& aSize, const

  1034     TDisplayMode aDisplayMode, const TInt aPriority, TAny* aClientData,

  1035     TBool aGeneratePersistentSizesOnly, const TDesC& aTargetUri, 

  1036     TThumbnailSize aThumbnailSize, TBool aOverwrite)

  1037     {

  1038     iRequestType = EReqSetThumbnailPath;

  1039     

  1040     iClientData = aClientData;

  1041     iParams.iControlFlags = (aGeneratePersistentSizesOnly ?

  1042                             EThumbnailGeneratePersistentSizesOnly :

  1043                             EThumbnailNoControlFlags);

  1044     iParams.iOriginalControlFlags = iParams.iControlFlags;

  1045     iParams.iMimeType = TDataType( aMimeType );

  1046     iParams.iBitmapHandle = 0;

  1047     iParams.iSize = aSize;

  1048     iParams.iDisplayMode = aDisplayMode;

  1049     iParams.iFileName = aPath;

  1050     iParams.iRequestId = iRequestId;

  1051     iParams.iPriority = aPriority;

  1052     iParams.iFlags = aFlags;

  1053     iParams.iQualityPreference = aQualityPreference;

  1054     iParams.iThumbnailSize = aThumbnailSize;

  1055     iParams.iOverwrite = aOverwrite;

  1056     

  1057     iTargetUri = aTargetUri;

  1058     

  1059     if (iTargetUri.Length() && IsVirtualUri(iTargetUri))

  1060         {

  1061         iParams.iVirtualUri = ETrue;

  1062         }

  1063     else

  1064         {

  1065         iParams.iVirtualUri = EFalse;

  1066         }

  1067     

  1068     iParams.iImport = ETrue;

  1069     }

  1070 

  1071 // ---------------------------------------------------------------------------

  1072 // Request 2nd phase thumbnail

  1073 // ---------------------------------------------------------------------------

  1074 //

  1075 void CThumbnailRequestActive::Get2ndPhaseThumbnailL()

  1076     {

  1077     TN_DEBUG2( "CThumbnailRequestActive::Get2ndPhaseThumbnailL() %d", iParams.iRequestId );

  1078     OstTrace1( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_GET2NDPHASETHUMBNAILL, "CThumbnailRequestActive::Get2ndPhaseThumbnailL;iParams.iRequestId=%u", iParams.iRequestId );

  1079     

  1080     iParams.iQualityPreference = CThumbnailManager::EOptimizeForQuality;

  1081     iParams.iControlFlags = EThumbnailNoControlFlags;

  1082     

  1083     if ( iMyFileHandle.SubSessionHandle())

  1084         {

  1085         User::LeaveIfError( iMyFileHandle.FullName( iParams.iFileName ));

  1086         iSession.RequestThumbnailL( iMyFileHandle, iParams.iTargetUri, iParamsPckg, iStatus );

  1087         SetActive();

  1088         }

  1089     else

  1090         {

  1091         iSession.RequestThumbnailL( iParams.iFileName, iParams.iTargetUri, iParams.iThumbnailId, iParamsPckg, iStatus );

  1092         SetActive();

  1093         }

  1094     }

  1095 

  1096 // ---------------------------------------------------------------------------

  1097 // CThumbnailRequestActive::ChangePriority()

  1098 // ---------------------------------------------------------------------------

  1099 //

  1100 void CThumbnailRequestActive::ChangePriority( const TInt aNewPriority )

  1101     {

  1102     TN_DEBUG1( "CThumbnailRequestActive::ChangePriority");

  1103     OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_CHANGEPRIORITY, "CThumbnailRequestActive::ChangePriority" );

  1104     

  1105     iParams.iPriority = aNewPriority;

  1106     

  1107     if (!IsActive())

  1108         {

  1109         this->SetPriority(aNewPriority);

  1110         }

  1111     else

  1112         {

  1113         iSession.ChangePriority(iRequestId, aNewPriority);

  1114         }

  1115     }

  1116 

  1117 // ---------------------------------------------------------------------------

  1118 // CThumbnailRequestActive::StartError()

  1119 // Error handling function.

  1120 // ---------------------------------------------------------------------------

  1121 //

  1122 void CThumbnailRequestActive::StartError( const TInt aErr )

  1123     {

  1124     TN_DEBUG1( "CThumbnailRequestActive::StartError");

  1125     OstTrace0( TRACE_NORMAL, CTHUMBNAILREQUESTACTIVE_STARTERROR, "CThumbnailRequestActive::StartError" );

  1126     

  1127     iStartError = aErr;

  1128     iRequestActive = ETrue;

  1129     

  1130     if (!iTimer->IsActive())

  1131         {

  1132         iTimer->Start( KClientRequestStartErrorTimeout, KClientRequestStartErrorTimeout, 

  1133                        TCallBack(TimerCallBack, this));

  1134         }

  1135     }