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:  Server side session for Thumbnail Manager Server

    15  *

    16 */

    17 

    18 #include <imageconversion.h> 

    19 

    20 #include "thumbnailserversession.h"

    21 #include "thumbnailserver.h"

    22 #include "thumbnailtaskprocessor.h"

    23 #include "thumbnailmanagerconstants.h"

    24 #include "thumbnailgeneratetask.h"

    25 #include "thumbnailscaletask.h"

    26 #include "thumbnaildecodetask.h"

    27 #ifdef RD_MDS_2_5

    28 #include "thumbnailmdsquerytask.h"

    29 #endif // RD_MDS_2_5

    30 #include "thumbnaillog.h"

    31 #include "thumbnailpanic.h"

    32 

    33 #include "thumbnailcenrep.h"

    34 #include "OstTraceDefinitions.h"

    35 #ifdef OST_TRACE_COMPILER_IN_USE

    36 #include "thumbnailserversessionTraces.h"

    37 #endif

    38 

    39 

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

    41 

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

    43 // CThumbnailServerSession::CThumbnailServerSession()

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

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

    46 //

    47 CThumbnailServerSession::CThumbnailServerSession(): CSession2()

    48     {

    49     iBitmapHandle = 0;

    50     iBitmap = NULL;

    51     iBuffer = NULL;

    52     }

    53 

    54 

    55 // ---------------------------------------------------------------------------

    56 // CThumbnailServerSession::~CThumbnailServerSession()

    57 // Destructor.

    58 // ---------------------------------------------------------------------------

    59 //

    60 CThumbnailServerSession::~CThumbnailServerSession()

    61     {

    62     Server()->DropSession(this);

    63     delete iBitmap;

    64     iBitmap = NULL;

    65     delete iBuffer;

    66     iBuffer = NULL;

    67     }

    68 

    69 

    70 // -----------------------------------------------------------------------------

    71 // CThumbnailServerSession::DispatchMessageL()

    72 // Message dispatcher.

    73 // -----------------------------------------------------------------------------

    74 //

    75 TInt CThumbnailServerSession::DispatchMessageL( const RMessage2& aMessage )

    76     {

    77     TInt err( KErrNone );

    78 

    79     switch ( aMessage.Function())

    80         {

    81         case ERequestThumbByFileHandleAsync:

    82                 {

    83                 RequestThumbByFileHandleAsyncL( aMessage );

    84                 break;

    85                 }

    86         case ERequestThumbByPathAsync:

    87                 {

    88                 RequestThumbByPathAsyncL( aMessage );

    89                 break;

    90                 }

    91         case ERequestSetThumbnailByBuffer:

    92                 {

    93                 RequestSetThumbnailByBufferL( aMessage );

    94                 break;

    95                 }

    96         case ERequestSetThumbnailByBitmap:

    97                 {

    98                 RequestSetThumbnailByBitmapL( aMessage );

    99                 break;

   100                 }                

   101         case EReleaseBitmap:

   102                 {

   103                 ReleaseBitmap( aMessage );

   104                 break;

   105                 }

   106         case ECancelRequest:

   107                 {

   108                 err = CancelRequest( aMessage );

   109                 break;

   110                 }

   111         case EChangePriority:

   112                 {

   113                 err = ChangePriority( aMessage );

   114                 break;

   115                 }

   116         case EDeleteThumbnails:

   117                 {

   118                 DeleteThumbnailsL( aMessage );

   119                 break;

   120                 }

   121         case EDeleteThumbnailsById:

   122                 {

   123                 DeleteThumbnailsByIdL( aMessage );

   124                 break;

   125                 }                

   126         case EGetMimeTypeBufferSize:

   127                 {

   128                 GetMimeTypeBufferSizeL( aMessage );

   129                 break;

   130                 }

   131         case EGetMimeTypeList:

   132                 {

   133                 GetMimeTypeListL( aMessage );

   134                 break;

   135                 }

   136         case ERequestThumbByIdAsync:

   137                 {

   138                 RequestThumbByIdAsyncL( aMessage );

   139                 break;

   140                 }

   141         case EUpdateThumbnails:

   142                 {

   143                 UpdateThumbnailsL( aMessage );

   144                 break;

   145                 }       

   146         case ERenameThumbnails:

   147                 {

   148                 RenameThumbnailsL( aMessage );

   149                 break;

   150                 } 

   151         default:

   152                 {

   153                 err = KErrUnknown;

   154                 break;

   155                 }

   156         }

   157 

   158     return err;

   159     }

   160 

   161 

   162 // ---------------------------------------------------------------------------

   163 // CThumbnailServerSession::CreateL()

   164 // ---------------------------------------------------------------------------

   165 //

   166 void CThumbnailServerSession::CreateL()

   167     {

   168     TN_DEBUG2( "CThumbnailServerSession::AddSession() = 0x%08x", this );

   169     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CREATEL, "CThumbnailServerSession::CreateL;this=%o", this );

   170     

   171     Server()->AddSession();

   172     }

   173 

   174 

   175 // -----------------------------------------------------------------------------

   176 // CThumbnailServerSession::ServiceL()

   177 // Handles service request messages from clients.

   178 // -----------------------------------------------------------------------------

   179 //

   180 void CThumbnailServerSession::ServiceL( const RMessage2& aMessage )

   181     {

   182     TN_DEBUG1( "CThumbnailServerSession::ServiceL() - begin" );

   183     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_SERVICEL, "CThumbnailServerSession::ServiceL - begin" );

   184     

   185     __ASSERT_DEBUG( !iMessage.Handle(), ThumbnailPanic(EThumbnailMessageNotCompleted));

   186     if ( iMessage.Handle())

   187         {

   188         iMessage.Complete( KErrUnknown );

   189         iMessage = RMessage2();

   190         }

   191     

   192     iMessage = aMessage;

   193 

   194     if ( iMessage.Handle())

   195         {

   196         // get client thread

   197         TInt err = iMessage.Client( iClientThread );

   198         if (err != KErrNone)

   199             {

   200             TN_DEBUG1( "CThumbnailServerSession::ServiceL() - client thread not found");

   201             OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_SERVICEL, "CThumbnailServerSession::ServiceL - client thread not found" );

   202     

   203             iMessage = RMessage2();

   204             }       

   205         }

   206     else

   207         {

   208         TN_DEBUG1( "CThumbnailServerSession::ServiceL() - message null");

   209         OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_SERVICEL, "CThumbnailServerSession::ServiceL - message null" );

   210         }

   211     

   212     // clean up possible trash

   213     if (iBitmapHandle)

   214         {

   215         Server()->DeleteBitmapFromPool( iBitmapHandle );

   216         iBitmapHandle = 0;

   217         }

   218     delete iBitmap;

   219     iBitmap = NULL;

   220     delete iBuffer;

   221     iBuffer = NULL;

   222     iOriginalSize = TSize();

   223     

   224     TInt ret = KErrNone;

   225 

   226     TRAPD( err, ret = DispatchMessageL( aMessage ) );

   227     

   228     // if message was not completed, or Leave occurred

   229     if ( iMessage.Handle())

   230         {

   231         if ( ClientThreadAlive() )

   232             {

   233             iMessage.Complete( ConvertSqlErrToE32Err( err != KErrNone ? err : ret ));        

   234             }

   235         

   236         iMessage = RMessage2();

   237         }

   238     

   239     // close thread handle

   240     iClientThread.Close();

   241     

   242     TN_DEBUG1( "CThumbnailServerSession::ServiceL() - end" );

   243     OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_SERVICEL, "CThumbnailServerSession::ServiceL - end" );

   244     }

   245 

   246 

   247 // -----------------------------------------------------------------------------

   248 // CThumbnailServerSession::Server()

   249 // Returns the server pointer.

   250 // -----------------------------------------------------------------------------

   251 //

   252 CThumbnailServer* CThumbnailServerSession::Server()

   253     {

   254     return ( CThumbnailServer* )( CSession2::Server());

   255     }

   256 

   257 

   258 // -----------------------------------------------------------------------------

   259 // CThumbnailServerSession::Cancel()

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

   261 //

   262 void CThumbnailServerSession::Cancel()

   263     {

   264     }

   265 

   266 

   267 // -----------------------------------------------------------------------------

   268 // CThumbnailServerSession::UpdateThumbnailsL()

   269 // -----------------------------------------------------------------------------

   270 //

   271 void CThumbnailServerSession::UpdateThumbnailsL( const RMessage2& aMessage )

   272     {

   273     TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL()" );

   274     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL" );

   275     

   276     if(aMessage.Int1() != KCheckValue)

   277        {

   278        TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - error in aMessage - leaving" );

   279        User::Leave(KErrArgument);

   280        }

   281     

   282     // read message params

   283     aMessage.ReadL( 0, iRequestParams );

   284     const TThumbnailRequestParams& params = iRequestParams();

   285     

   286     TBool finished = Server()->UpdateThumbnailsL( params.iFileName, params.iOrientation, params.iModified );

   287     

   288     RArray < TThumbnailPersistentSize >* missingSizes = NULL;

   289     

   290     TBool gridSizeOnly(EFalse);

   291             

   292     if ( params.iQualityPreference == CThumbnailManager

   293                     ::EOptimizeForQualityWithPreview )

   294         {

   295         gridSizeOnly = ETrue;

   296         }

   297     

   298     if (finished)

   299         {

   300         // source type

   301         TDataType mimeType;

   302         TInt sourceType = 0;

   303         TInt err = Server()->MimeTypeFromFileExt( params.iFileName, mimeType );

   304         

   305         // need to use recognizer

   306         if (err == KErrNotFound)

   307             {

   308             Server()->Fs().ShareProtected();

   309             RFile64 file;

   310             CleanupClosePushL( file );

   311           

   312             User::LeaveIfError( file.Open( Server()->Fs(), params.iFileName, EFileShareReadersOrWriters )); 

   313             TN_DEBUG2( "CThumbnailServerSession::UpdateThumbnailsL - file handle opened for %S", &params.iFileName );

   314           

   315             mimeType = Server()->ResolveMimeTypeL(file);

   316           

   317             file.Close();

   318             TN_DEBUG1("CThumbnailServerSession::UpdateThumbnailsL - file handle closed");

   319           

   320             CleanupStack::Pop( &file );    

   321             }

   322         

   323         // get missing sizes

   324         if ( ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )

   325             {

   326             sourceType = Server()->SourceTypeFromMimeType( mimeType );

   327             

   328             missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;

   329             CleanupClosePushL( *missingSizes );

   330         

   331             Server()->GetMissingSizesL( params.iFileName, sourceType, *missingSizes, gridSizeOnly );

   332                 

   333             if ( missingSizes->Count() == 0)

   334                 {

   335                 // all thumbs already exist

   336                 CleanupStack::PopAndDestroy( missingSizes );

   337                 delete missingSizes;

   338                 missingSizes = NULL;

   339                 }            

   340             }

   341         

   342         if(!missingSizes)

   343             {

   344             TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished part 1" );

   345             OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL - finished part 1" );

   346             aMessage.Complete( KErrNone );

   347             }

   348         else

   349             {

   350             OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL  - some sizes missing..." );

   351             TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - some sizes missing..." ); 

   352             }

   353         }

   354 

   355     if (missingSizes || !finished)

   356         {

   357         TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - need to create (some) thumbs" );

   358         OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL - need to create (some) thumbs" );

   359         

   360         if(missingSizes)

   361             {

   362             CleanupStack::PopAndDestroy( missingSizes );

   363             delete missingSizes;

   364             missingSizes = NULL;

   365             }

   366         

   367         if(Server()->StoreForPathL(params.iFileName)->IsDiskFull())

   368             {

   369             User::Leave( KErrDiskFull );

   370             }

   371         

   372         // need to create new thumbs

   373         aMessage.Complete( KThumbnailErrThumbnailNotFound );

   374         }

   375     else

   376         {

   377         TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished part 2" );

   378         OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL - finished part 2" );

   379         }

   380     

   381     iMessage = RMessage2();

   382     }

   383 

   384 // -----------------------------------------------------------------------------

   385 // CThumbnailServerSession::RenameThumbnailsL()

   386 // Rename thumbnails.

   387 // -----------------------------------------------------------------------------

   388 //

   389 void CThumbnailServerSession::RenameThumbnailsL( const RMessage2& aMessage )

   390     {

   391     if(aMessage.Int1() != KCheckValue)

   392        {

   393        TN_DEBUG1( "CThumbnailServerSession::RenameThumbnailsL() - error in aMessage - leaving" );

   394        OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_RENAMETHUMBNAILSL, "CThumbnailServerSession::RenameThumbnailsL - error in aMessage - leaving" );

   395        User::Leave(KErrArgument);

   396        }

   397     

   398     // read message params

   399     aMessage.ReadL( 0, iRequestParams );

   400     const TThumbnailRequestParams& params = iRequestParams();

   401     

   402     // renaming only inside one store

   403     if (params.iFileName.Left(1).CompareF( params.iTargetUri.Left(1) ) == 0)

   404         {

   405         Server()->RenameThumbnailsL( params.iFileName, params.iTargetUri );

   406         

   407         aMessage.Complete( KErrNone );

   408         }

   409     else

   410         {

   411         aMessage.Complete( KErrNotSupported );

   412         }

   413     

   414     iMessage = RMessage2();

   415     }

   416 

   417 // -----------------------------------------------------------------------------

   418 // CThumbnailServerSession::RequestThumbByIdAsyncL()

   419 // -----------------------------------------------------------------------------

   420 //

   421 void CThumbnailServerSession::RequestThumbByIdAsyncL( const RMessage2&

   422     aMessage )

   423     {

   424 #ifdef _DEBUG

   425     TTime aStart, aStop;

   426     aStart.UniversalTime();

   427 #endif

   428     

   429     TN_DEBUG1( "CThumbnailServerSession::RequestThumbByIdAsyncL() - begin" );

   430     

   431     if(aMessage.Int1() != KCheckValue)

   432        {

   433        TN_DEBUG1( "CThumbnailServerSession::RequestThumbByIdAsync() - error in aMessage - leaving" );

   434        OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYIDASYNCL, "CThumbnailServerSession::RequestThumbByIdAsyncL - leaving" );

   435        User::Leave(KErrArgument);

   436        }

   437 

   438     aMessage.ReadL( 0, iRequestParams );

   439     const TThumbnailRequestParams& params = iRequestParams();

   440     

   441 #ifdef RD_MDS_2_5        

   442         // try to query path from MDS

   443         CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(

   444                 Server()->Processor(), params.iPriority + 1, Server()->GetMdESession(), *Server());

   445         

   446         CleanupStack::PushL( task );

   447         task->QueryPathByIdL(params.iThumbnailId, EFalse);

   448         task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage, iClientThread );

   449         Server()->QueueTaskL( task );

   450         CleanupStack::Pop( task ); // owned by processor now

   451         

   452         // query task is now responsible for completing the message

   453         iMessage = RMessage2();

   454 #else

   455         User::Leave(KErrNotSupported);

   456 #endif // RD_MDS_2_5

   457         

   458     

   459 #ifdef _DEBUG

   460     aStop.UniversalTime();

   461     TInt tookTime = (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000;

   462     TN_DEBUG2( "CThumbnailServerSession::RequestThumbByIdAsyncL() request took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000 );

   463     OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYIDASYNCL, "CThumbnailServerSession::RequestThumbByIdAsyncL;tookTime=%d", tookTime );

   464 #endif 

   465     

   466     TN_DEBUG1("CThumbnailServerSession::RequestThumbByIdAsyncL() - end" );

   467     OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYIDASYNCL, "CThumbnailServerSession::RequestThumbByIdAsyncL - end" );

   468     }

   469 

   470 // -----------------------------------------------------------------------------

   471 // CThumbnailServerSession::RequestThumbByFileHandleAsync()

   472 // -----------------------------------------------------------------------------

   473 //

   474 void CThumbnailServerSession::RequestThumbByFileHandleAsyncL( const RMessage2&

   475     aMessage )

   476     {

   477     TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL()" );

   478     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL" );

   479     

   480     if(aMessage.Int1() != KCheckValue)

   481        {

   482        TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsync() - error in aMessage - leaving" );

   483        OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - error in aMessage - leaving" );

   484        User::Leave(KErrArgument);

   485        }

   486     

   487     aMessage.ReadL( 0, iRequestParams );

   488     const TThumbnailRequestParams& params = iRequestParams();

   489 

   490     RFile64 file;

   491     CleanupClosePushL(file);

   492     User::LeaveIfError( file.AdoptFromClient( aMessage, 2, 3 ));

   493     

   494     ResolveMimeTypeL(&file);

   495     

   496     if(params.iThumbnailSize == EFullScreenThumbnailSize ||

   497        params.iThumbnailSize == EGridThumbnailSize ||

   498        params.iThumbnailSize == EListThumbnailSize )

   499         {

   500         TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

   501         sourceType = Server()->SourceTypeFromMimeType( params.iMimeType );

   502         ModifyThumbnailSize(sourceType);

   503         }

   504     

   505     // delete existing

   506     if(params.iImport && params.iOverwrite)

   507         {

   508         Server()->DeleteThumbnailsL( params.iTargetUri);

   509         }

   510     

   511     // CreateThumbnails

   512     if (params.iControlFlags == EThumbnailGeneratePersistentSizesOnly)

   513         {

   514         TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - EThumbnailGeneratePersistentSizesOnly" );

   515         OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - EThumbnailGeneratePersistentSizesOnly" );

   516         CreateGenerateTaskFromFileHandleL( &file );

   517         

   518         // ownership of the file transferred

   519         CleanupStack::Pop(&file);

   520         }

   521     // single thumbnail request

   522     else

   523         {

   524         TRAPD( err, FetchThumbnailL());

   525         

   526         if( err == KErrCompletion )

   527             {

   528             // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion

   529             TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail blacklisted" );

   530             OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - thumbnail blacklisted" );

   531             

   532             aMessage.Complete( err );

   533             iMessage = RMessage2();

   534             

   535             // close file

   536             CleanupStack::PopAndDestroy(&file);

   537             }

   538         else if ( !err && iBitmap )

   539             {

   540             TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - bitmap " );

   541             OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - found existing thumbnail - bitmap " );

   542 

   543             // Thumbnail already stored

   544             CleanupStack::PopAndDestroy(&file);

   545             TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed");

   546             OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed" );

   547 

   548             ProcessBitmapL();

   549             }

   550         else if ( (err == KErrNotFound || err == KErrAccessDenied) && 

   551                  !(params.iFlags& CThumbnailManager::EDoNotCreate) )

   552             {

   553             TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - KErrNotFound & !EDoNotCreate" );

   554             OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - KErrNotFound & !EDoNotCreate" );

   555             CreateGenerateTaskFromFileHandleL( &file);

   556             

   557             // ownership of the file transferred

   558         	CleanupStack::Pop(&file);

   559             }

   560         else if (!err && iBuffer)

   561             {

   562             TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - jpeg " );

   563             OstTrace0( TRACE_NORMAL, DUP7_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - found existing thumbnail - jpeg" );

   564             

   565             CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()

   566                         ->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );

   567             

   568             CleanupStack::PushL( task );

   569             task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage, iClientThread );

   570             Server()->QueueTaskL( task );

   571             CleanupStack::Pop( task ); // owned by processor now

   572             

   573             // Decode task is now responsible for completing the message

   574             iMessage = RMessage2();

   575             

   576             //CThumbnailDecodeTask is responsible freeing

   577             iBuffer = NULL;

   578             

   579             // close file

   580             CleanupStack::PopAndDestroy(&file);

   581             TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed");

   582             OstTrace0( TRACE_NORMAL, DUP8_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed" );

   583             }

   584         else

   585             {

   586             TN_DEBUG2( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail not found, err=%d", err );

   587             OstTrace1( TRACE_NORMAL, DUP9_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - thumbnail not found;err=%d", err );

   588             

   589             aMessage.Complete( ConvertSqlErrToE32Err( err ));

   590             iMessage = RMessage2();

   591             

   592             // close file

   593             CleanupStack::PopAndDestroy(&file);

   594             }     

   595         }

   596     }

   597 

   598 // -----------------------------------------------------------------------------

   599 // CThumbnailServerSession::RequestThumbByPathAsync()

   600 // -----------------------------------------------------------------------------

   601 //

   602 void CThumbnailServerSession::RequestThumbByPathAsyncL( const RMessage2&

   603     aMessage )

   604     {

   605     TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsyncL()" );

   606     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL" );

   607     

   608 #ifdef _DEBUG

   609     TTime aStart, aStop;

   610     aStart.UniversalTime();

   611 #endif

   612     

   613     if(aMessage.Int1() != KCheckValue)

   614        {

   615        TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsync() - error in aMessage - leaving" );

   616        OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL - error in aMessage - leaving" );

   617        User::Leave(KErrArgument);

   618        }

   619 

   620     aMessage.ReadL( 0, iRequestParams );

   621     const TThumbnailRequestParams& params = iRequestParams();

   622     

   623     ResolveMimeTypeL(NULL);

   624     

   625     if(params.iThumbnailSize == EFullScreenThumbnailSize ||

   626        params.iThumbnailSize == EGridThumbnailSize ||

   627        params.iThumbnailSize == EListThumbnailSize )

   628         {

   629         TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

   630         sourceType = Server()->SourceTypeFromMimeType( params.iMimeType );

   631         ModifyThumbnailSize(sourceType);

   632         }

   633     

   634     // should always be true

   635     if (params.iControlFlags != EThumbnailGeneratePersistentSizesOnly)

   636 		{

   637 	    TRAPD( err, FetchThumbnailL());

   638 	    

   639 	    if ( !err && iBitmap )

   640 	        {

   641 	        TN_DEBUG1( 

   642 	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - found existing thumbnail- bitmap" );

   643 	        OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL - found existing thumbnail- bitmap" );

   644 

   645 	        ProcessBitmapL();

   646 	        }

   647 	    else if ( !err && iBuffer)

   648 	        {

   649 	        TN_DEBUG1( 

   650 	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - found existing thumbnail- jpeg" );

   651 	        OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL - found existing thumbnail- jpeg" );

   652 	        

   653 	        CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()

   654 	               ->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );

   655 	        

   656 	        CleanupStack::PushL( task );

   657 	        task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage, iClientThread );

   658 	        Server()->QueueTaskL( task );

   659 	        CleanupStack::Pop( task ); // owned by processor now

   660 	        

   661 	        // Decode task is now responsible for completing the message

   662 	        iMessage = RMessage2();

   663 	        

   664 	        //CThumbnailDecodeTask is responsible freeing

   665 	        iBuffer = NULL;

   666 	        }

   667 	    else if( err == KErrCompletion )

   668 	        {

   669             // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion

   670             TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail blacklisted" );

   671             OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL - thumbnail blacklisted" );

   672             

   673             aMessage.Complete( err );

   674             iMessage = RMessage2();

   675 	        }

   676 	    else 

   677 	        {

   678 	        TN_DEBUG2( 

   679 	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail not found, err = %d", err );

   680 	        OstTrace1( TRACE_NORMAL, DUP5_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL  - thumbnail not found;err=%d", err );

   681 	        

   682 	        // don't try to create from virtual URI

   683 	        if ( params.iVirtualUri )

   684 	            {

   685                 User::Leave(err);

   686 	            }

   687 	        

   688             // disk space check only for stored sizes

   689             if ( params.iThumbnailSize != ECustomThumbnailSize && 

   690                  Server()->StoreForPathL(params.iFileName)->IsDiskFull() )

   691                 {

   692                 User::Leave( KErrDiskFull );

   693                 }

   694 	        

   695 	        if ( (err == KErrNotFound || err == KErrAccessDenied) && 

   696 	            !(params.iFlags& CThumbnailManager::EDoNotCreate) )

   697 	            {

   698 	            // Special error code so that the client side can open the file

   699 	            // and retry the request using file handle

   700 	            err = KThumbnailErrThumbnailNotFound;

   701 	            }

   702 

   703             User::Leave(err);

   704 	        }   

   705 	   }

   706     

   707 #ifdef _DEBUG

   708     aStop.UniversalTime();

   709     TInt tookTime = (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000;

   710     TN_DEBUG2( "CThumbnailStore::RequestThumbByPathAsyncL() request took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000 );

   711     OstTrace1( TRACE_NORMAL, DUP6_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL;tookTime=%d", tookTime );

   712 #endif

   713     }   

   714     

   715 void CThumbnailServerSession::RequestSetThumbnailByBufferL( const RMessage2& aMessage )

   716     {

   717     TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBufferL()" );

   718     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBUFFERL, "CThumbnailServerSession::RequestSetThumbnailByBufferL" );

   719     

   720     if(aMessage.Int3() != KCheckValue)

   721         {

   722         TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBufferL() - error in aMessage - leaving" );

   723         OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBUFFERL, "CThumbnailServerSession::RequestSetThumbnailByBufferL - error in aMessage - leaving" );

   724         User::Leave(KErrArgument);

   725         }

   726       

   727     aMessage.ReadL( 0, iRequestParams );

   728     const TThumbnailRequestParams& params = iRequestParams();

   729     

   730     // delete existing

   731     if(params.iOverwrite)

   732         {

   733         Server()->DeleteThumbnailsL( params.iTargetUri);

   734         }

   735     

   736     // if only one size

   737     if ((params.iControlFlags & EThumbnailGeneratePersistentSizesOnly) == 0)

   738         {

   739         if(params.iThumbnailSize == EFullScreenThumbnailSize ||

   740            params.iThumbnailSize == EGridThumbnailSize ||

   741            params.iThumbnailSize == EListThumbnailSize )

   742            {

   743            TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

   744            TDataType mimetype;

   745            TInt ret = Server()->MimeTypeFromFileExt( params.iTargetUri, mimetype );

   746            

   747            if( ret == KErrNone )

   748                {

   749                sourceType = Server()->SourceTypeFromMimeType( mimetype );   

   750                ModifyThumbnailSize(sourceType);

   751                }

   752            User::LeaveIfError( ret );

   753            }

   754         }

   755     

   756     TInt bufferSize = aMessage.Int2();

   757     HBufC8* buffer = HBufC8::NewMaxLC( bufferSize );

   758     TPtr8 ptr = buffer->Des();

   759     aMessage.ReadL( 1 /* buffer pointer */, ptr );

   760     

   761     CreateGenerateTaskFromBufferL( buffer );

   762     CleanupStack::Pop( buffer );

   763     }

   764 

   765 void CThumbnailServerSession::RequestSetThumbnailByBitmapL( const RMessage2& aMessage )

   766     {

   767     TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBitmapL()" );

   768     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBITMAPL, "CThumbnailServerSession::RequestSetThumbnailByBitmapL" );

   769 

   770     if(aMessage.Int2() != KCheckValue)

   771         {

   772         TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBitmapL() - error in aMessage - leaving" );

   773         OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBITMAPL, "CThumbnailServerSession::RequestSetThumbnailByBitmapL - error in aMessage - leaving" );

   774         User::Leave(KErrArgument);

   775         }

   776         

   777     aMessage.ReadL( 0, iRequestParams );

   778     const TThumbnailRequestParams& params = iRequestParams();

   779     

   780     const TThumbnailServerRequestId reqId( this, params.iRequestId );

   781     

   782     // delete existing

   783     if(params.iOverwrite)

   784         {

   785         Server()->DeleteThumbnailsL( params.iTargetUri);

   786         }

   787     

   788     // if only one size

   789     if ((params.iControlFlags & EThumbnailGeneratePersistentSizesOnly) == 0)

   790         {

   791         if(params.iThumbnailSize == EFullScreenThumbnailSize ||

   792            params.iThumbnailSize == EGridThumbnailSize ||

   793            params.iThumbnailSize == EListThumbnailSize )

   794            {

   795            TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

   796            TDataType mimetype;

   797            TInt ret = Server()->MimeTypeFromFileExt( params.iTargetUri, mimetype );

   798            

   799            if( ret == KErrNone )

   800                {

   801                sourceType = Server()->SourceTypeFromMimeType( mimetype );   

   802                ModifyThumbnailSize(sourceType);

   803                }

   804            User::LeaveIfError( ret );

   805            }

   806         }

   807     

   808     TInt bitmapHandle = aMessage.Int1();

   809     

   810     // get bitmap

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

   812     CleanupStack::PushL( bitmap );

   813     User::LeaveIfError( bitmap->Duplicate( bitmapHandle ) );

   814 

   815     // use pool to prevent bitmap leak

   816     // this bitmap is shared to several scale tasks, one of which can Leave

   817     Server()->AddBitmapToPoolL( this, bitmap, reqId );

   818     

   819     CleanupStack::Pop( bitmap );

   820     iBitmapHandle = bitmap->Handle();

   821     

   822     RArray < TThumbnailPersistentSize >* missingSizes = NULL;

   823     

   824     // source type

   825     TDataType mimeType;

   826     TInt sourceType = 0;

   827     TInt err = Server()->MimeTypeFromFileExt( params.iTargetUri, mimeType );

   828     

   829     // get missing sizes

   830     if ( err == KErrNone && ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )

   831         {

   832         sourceType = Server()->SourceTypeFromMimeType( mimeType );

   833         

   834         missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;

   835         CleanupClosePushL( *missingSizes );

   836     

   837         Server()->GetMissingSizesL( params.iTargetUri, sourceType, *missingSizes, EFalse);

   838             

   839         if ( missingSizes->Count() == 0)

   840             {

   841             // all thumbs already exist

   842             CleanupStack::PopAndDestroy( missingSizes );

   843             delete missingSizes;

   844             missingSizes = NULL;

   845             }            

   846         }

   847     

   848     // if missing sizes, create scale tasks

   849     if ( missingSizes )

   850         {

   851         const TInt count = missingSizes->Count();

   852         

   853         TSize bitmapSize = bitmap->SizeInPixels();

   854         

   855         // scale small thumbs first, because fullscreen encoding takes longer

   856         for ( TInt i( count-1 ); i >= 0; i-- )

   857             {           

   858             if( bitmapSize.iWidth < bitmapSize.iHeight )

   859                {

   860                TThumbnailSize size = (*missingSizes)[ i ].iType;

   861         

   862                if ( size == EFullScreenThumbnailSize ||

   863                     size == EVideoFullScreenThumbnailSize ||

   864                     size == EAudioFullScreenThumbnailSize ||

   865                     size == EImageFullScreenThumbnailSize ||

   866                     size == EContactFullScreenThumbnailSize )

   867                    {

   868                    TInt height = (*missingSizes)[i].iSize.iHeight;

   869                    (*missingSizes)[i].iSize.iHeight = (*missingSizes)[i].iSize.iWidth;

   870                    (*missingSizes)[i].iSize.iWidth = height;

   871                     

   872                    TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBitmapL() - portrait");

   873                    OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBITMAPL, "CThumbnailServerSession::RequestSetThumbnailByBitmapL - portrait" );

   874                    }

   875                }

   876         

   877             CThumbnailScaleTask* scaleTask = CThumbnailScaleTask::NewL( Server()->Processor(),

   878                     *Server(), params.iTargetUri, bitmap, bitmapSize,

   879                     (*missingSizes)[i].iSize, (*missingSizes)[i].iCrop, params.iDisplayMode,

   880                     KMaxPriority, KNullDesC, (*missingSizes)[i].iType, params.iModified, EFalse, EFalse,

   881                     reqId, params.iVirtualUri);

   882             

   883             CleanupStack::PushL( scaleTask );

   884             scaleTask->SetDoStore( ETrue );

   885             Server()->Processor().AddTaskL( scaleTask );

   886             CleanupStack::Pop( scaleTask );

   887         

   888             // completion to first task, because task processor works like stack

   889             if( i == 0 )

   890                 {            

   891                 // scaleTask is now responsible for completing the RMessage

   892                 scaleTask->SetMessageData( reqId, iMessage, iClientThread );

   893                 iMessage = RMessage2();

   894                 }

   895             }

   896         }

   897     else

   898         {

   899         // complete message

   900         aMessage.Complete( KErrNone );

   901         iMessage = RMessage2();

   902         }

   903     

   904     if ( missingSizes )

   905         {

   906         CleanupStack::PopAndDestroy( missingSizes );

   907         delete missingSizes;

   908         missingSizes = NULL;

   909         }

   910     

   911     // Scale tasks now reference the bitmap in the pool

   912     Server()->DeleteBitmapFromPool( iBitmapHandle );

   913     iBitmapHandle = 0;

   914     bitmap = NULL;

   915     }

   916  

   917 // -----------------------------------------------------------------------------

   918 // CThumbnailServerSession::CreateGenerateTaskL()

   919 // Create a task to generate a new thumbnail

   920 // -----------------------------------------------------------------------------

   921 //

   922 void CThumbnailServerSession::CreateGenerateTaskFromFileHandleL( RFile64* aFile)

   923     {

   924     TThumbnailRequestParams& params = iRequestParams();

   925 

   926     TN_DEBUG2( 

   927         "CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() -- create thumbnail generation task for %S", &params.iFileName );

   928     OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMFILEHANDLEL, "CThumbnailServerSession::CreateGenerateTaskFromFileHandleL -- create thumbnail generation task for;params.iFileName=%S", params.iFileName );

   929     

   930     // disk space check only for stored sizes

   931     if ( params.iImport && 

   932          Server()->StoreForPathL(params.iTargetUri)->IsDiskFull() )

   933         {

   934         User::Leave( KErrDiskFull );

   935         }

   936     else if ( params.iThumbnailSize != ECustomThumbnailSize && 

   937          Server()->StoreForPathL(params.iFileName)->IsDiskFull() )

   938         {

   939         User::Leave( KErrDiskFull );

   940         }

   941     

   942     RArray < TThumbnailPersistentSize >* missingSizes = NULL;

   943     

   944     // get missing sizes

   945     if ( ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )

   946         {

   947         TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

   948         sourceType = Server()->SourceTypeFromMimeType( params.iMimeType );

   949         missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;

   950         CleanupClosePushL( *missingSizes );

   951 		

   952 	    TBool gridSizeOnly(EFalse);

   953             

   954 	    if ( params.iQualityPreference == CThumbnailManager::EOptimizeForQualityWithPreview )

   955 	        {

   956 	        gridSizeOnly = ETrue;

   957 	        }

   958         

   959 	    // import vs. normal

   960 	    if(params.iImport)

   961 	        {

   962             Server()->GetMissingSizesL( params.iTargetUri, sourceType, *missingSizes, gridSizeOnly);

   963 	        }

   964 	    else

   965 	        {

   966             Server()->GetMissingSizesL( params.iFileName, sourceType, *missingSizes, gridSizeOnly);

   967 	        }     

   968         

   969         if ( missingSizes->Count() == 0)

   970             {

   971             // all thumbs already exist

   972             CleanupStack::PopAndDestroy( missingSizes );

   973             delete missingSizes;

   974             missingSizes = NULL;

   975             

   976             if( aFile )

   977                {

   978                aFile->Close();

   979                }

   980             return;

   981             }            

   982         }

   983     // creating single TN on demand

   984     else if( params.iThumbnailSize > ECustomThumbnailSize && params.iThumbnailSize  < EThumbnailSizeCount)

   985         {

   986         TThumbnailPersistentSize persistentSize = Server()->PersistentSizeL(params.iThumbnailSize);

   987         

   988         if(persistentSize.iCrop)

   989             {

   990             params.iFlags = ( CThumbnailManager::TThumbnailFlags ) (params.iFlags | CThumbnailManager::ECropToAspectRatio);

   991             }

   992         else

   993             {

   994             params.iFlags = ( CThumbnailManager::TThumbnailFlags ) (params.iFlags & CThumbnailManager::ECropToAspectRatio);

   995             }

   996         

   997         if( ClientThreadAlive() )

   998             {

   999             iMessage.Write( 0, iRequestParams );

  1000             }

  1001         }

  1002     

  1003     // priority

  1004     TInt priority = params.iPriority;

  1005     if ( priority > KMaxGeneratePriority )

  1006         {

  1007         priority = KMaxGeneratePriority;

  1008         }

  1009     

  1010     // create new task

  1011     if( !aFile)

  1012         {

  1013         TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() - KErrArgument");

  1014         OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMFILEHANDLEL, "CThumbnailServerSession::CreateGenerateTaskFromFileHandleL - KErrArgument" );

  1015         User::Leave( KErrArgument );

  1016         }

  1017     CleanupClosePushL( *aFile );

  1018     CThumbnailGenerateTask* task = new( ELeave )CThumbnailGenerateTask( Server()

  1019         ->Processor(), * Server(), aFile, NULL, &params.iMimeType, params.iFlags,

  1020         params.iSize, params.iDisplayMode, priority, missingSizes, params.iTargetUri,

  1021         params.iThumbnailSize, params.iModified, params.iQualityPreference,

  1022         params.iVirtualUri);

  1023 

  1024     // do not store bitmaps to server pool when generating only

  1025     if( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly )

  1026         {

  1027         task->ScaledBitmapToPool( EFalse );

  1028         }

  1029         

  1030     CleanupStack::Pop( aFile );

  1031     

  1032     CleanupStack::PushL( task );

  1033     task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ),iMessage, iClientThread );

  1034     Server()->QueueTaskL( task );

  1035     CleanupStack::Pop( task ); // owned by processor now

  1036     

  1037     if ( missingSizes )

  1038         {

  1039         CleanupStack::Pop( missingSizes );

  1040         }

  1041 

  1042     // Generate task is now responsible for completing the message

  1043     iMessage = RMessage2();

  1044     } 

  1045 

  1046 // -----------------------------------------------------------------------------

  1047 // CThumbnailServerSession::CreateGenerateTaskL()

  1048 // Create a task to generate a new thumbnail

  1049 // -----------------------------------------------------------------------------

  1050 //

  1051 void CThumbnailServerSession::CreateGenerateTaskFromBufferL( TDesC8* aBuffer )

  1052     {

  1053     const TThumbnailRequestParams& params = iRequestParams();

  1054 

  1055     TN_DEBUG2( 

  1056         "CThumbnailServerSession::CreateGenerateTaskFromBufferL() -- create thumbnail generation task for %S", &params.iTargetUri );

  1057     OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMBUFFERL, "CThumbnailServerSession::CreateGenerateTaskFromBufferL -  -- create thumbnail generation task for;params.iTargetUri=%S", params.iTargetUri );

  1058   

  1059     // disk space check only for stored sizes

  1060     if ( params.iThumbnailSize != ECustomThumbnailSize && 

  1061          Server()->StoreForPathL(params.iTargetUri)->IsDiskFull() )

  1062         {

  1063         User::Leave( KErrDiskFull );

  1064         }

  1065     

  1066     if(aBuffer && params.iMimeType.Des().Match( KVideoMime ) == 0 )

  1067         {

  1068         User::Leave( KErrNotSupported );

  1069         }

  1070     

  1071     TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

  1072     

  1073     TDataType mimetype;

  1074     TInt ret = Server()->MimeTypeFromFileExt( params.iTargetUri, mimetype );

  1075     if(ret == KErrNotFound)

  1076         {

  1077         Server()->Fs().ShareProtected();

  1078         RFile64 file;

  1079         CleanupClosePushL( file );

  1080         

  1081         User::LeaveIfError( file.Open( Server()->Fs(), params.iTargetUri, EFileShareReadersOrWriters )); 

  1082         TN_DEBUG2( "CThumbnailServerSession::CreateGenerateTaskFromBufferL - file handle opened for %S", &params.iFileName );

  1083                 OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMBUFFERL, "CThumbnailServerSession::CreateGenerateTaskFromBufferL;params.iFileName=%S", params.iFileName );

  1084                 

  1085         mimetype = Server()->ResolveMimeTypeL(file);

  1086                 

  1087         file.Close();

  1088         TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromBufferL - file handle closed");

  1089         OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMBUFFERL, "CThumbnailServerSession::CreateGenerateTaskFromBufferL - file handle closed" );

  1090         

  1091         CleanupStack::Pop( &file );    

  1092         }

  1093         

  1094     sourceType = Server()->SourceTypeFromMimeType( mimetype );    

  1095     

  1096     RArray < TThumbnailPersistentSize >* missingSizes = NULL;

  1097     

  1098     // get missing sizes

  1099     if ( ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )

  1100         {

  1101         missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;

  1102         CleanupClosePushL( *missingSizes );

  1103         

  1104         Server()->GetMissingSizesL( params.iTargetUri, sourceType, *missingSizes, EFalse );

  1105             

  1106         if ( missingSizes->Count() == 0)

  1107             {

  1108             // all thumbs already exist

  1109             CleanupStack::PopAndDestroy( missingSizes );

  1110             delete missingSizes;

  1111             missingSizes = NULL;

  1112             

  1113             if ( aBuffer)

  1114                {

  1115                delete aBuffer;

  1116                aBuffer = NULL; 

  1117                }

  1118             return;

  1119             }            

  1120         }

  1121     

  1122     // priority

  1123     TInt priority = params.iPriority;

  1124     if ( priority > KMaxGeneratePriority )

  1125         {

  1126         priority = KMaxGeneratePriority;

  1127         }

  1128     

  1129     // create new task

  1130     if( !aBuffer)

  1131         {

  1132         TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - KErrArgument" );

  1133         OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMBUFFERL, "CThumbnailServerSession::CreateGenerateTaskFromBufferL - KErrArgument" );

  1134         User::Leave( KErrArgument );

  1135         }