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 

    35 // ======== MEMBER FUNCTIONS ========

    36 

    37 // ---------------------------------------------------------------------------

    38 // CThumbnailServerSession::CThumbnailServerSession()

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

    40 // ---------------------------------------------------------------------------

    41 //

    42 CThumbnailServerSession::CThumbnailServerSession(): CSession2()

    43     {

    44     iBitmapHandle = 0;

    45     }

    46 

    47 

    48 // ---------------------------------------------------------------------------

    49 // CThumbnailServerSession::~CThumbnailServerSession()

    50 // Destructor.

    51 // ---------------------------------------------------------------------------

    52 //

    53 CThumbnailServerSession::~CThumbnailServerSession()

    54     {

    55     Server()->DropSession(this);

    56     }

    57 

    58 

    59 // -----------------------------------------------------------------------------

    60 // CThumbnailServerSession::DispatchMessageL()

    61 // Message dispatcher.

    62 // -----------------------------------------------------------------------------

    63 //

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

    65     {

    66     TInt err( KErrNone );

    67 

    68     switch ( aMessage.Function())

    69         {

    70         case ERequestThumbByFileHandleAsync:

    71                 {

    72                 RequestThumbByFileHandleAsyncL( aMessage );

    73                 break;

    74                 }

    75         case ERequestThumbByPathAsync:

    76                 {

    77                 RequestThumbByPathAsyncL( aMessage );

    78                 break;

    79                 }

    80         case ERequestSetThumbnailByBuffer:

    81                 {

    82                 RequestSetThumbnailByBufferL( aMessage );

    83                 break;

    84                 }

    85         case ERequestSetThumbnailByBitmap:

    86                 {

    87                 RequestSetThumbnailByBitmapL( aMessage );

    88                 break;

    89                 }                

    90         case EReleaseBitmap:

    91                 {

    92                 ReleaseBitmap( aMessage );

    93                 break;

    94                 }

    95         case ECancelRequest:

    96                 {

    97                 err = CancelRequest( aMessage );

    98                 break;

    99                 }

   100         case EChangePriority:

   101                 {

   102                 err = ChangePriority( aMessage );

   103                 break;

   104                 }

   105         case ECreateThumbnails:

   106                 {

   107                 CreateThumbnailsL( aMessage );

   108                 break;

   109                 }

   110         case EDeleteThumbnails:

   111                 {

   112                 DeleteThumbnailsL( aMessage );

   113                 break;

   114                 }

   115         case EDeleteThumbnailsById:

   116                 {

   117                 DeleteThumbnailsByIdL( aMessage );

   118                 break;

   119                 }                

   120         case EGetMimeTypeBufferSize:

   121                 {

   122                 GetMimeTypeBufferSizeL( aMessage );

   123                 break;

   124                 }

   125         case EGetMimeTypeList:

   126                 {

   127                 GetMimeTypeListL( aMessage );

   128                 break;

   129                 }

   130         case ERequestThumbByIdAsync:

   131                 {

   132                 RequestThumbByIdAsyncL( aMessage );

   133                 break;

   134                 }

   135         case EUpdateThumbnails:

   136                 {

   137                 UpdateThumbnailsL( aMessage );

   138                 break;

   139                 }                  

   140         default:

   141                 {

   142                 err = KErrUnknown;

   143                 break;

   144                 }

   145         }

   146 

   147     return err;

   148     }

   149 

   150 

   151 // ---------------------------------------------------------------------------

   152 // CThumbnailServerSession::CreateL()

   153 // ---------------------------------------------------------------------------

   154 //

   155 void CThumbnailServerSession::CreateL()

   156     {

   157     Server()->AddSession();

   158     }

   159 

   160 

   161 // -----------------------------------------------------------------------------

   162 // CThumbnailServerSession::ServiceL()

   163 // Handles service request messages from clients.

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

   165 //

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

   167     {

   168     __ASSERT_DEBUG( !iMessage.Handle(), ThumbnailPanic(

   169         EThumbnailMessageNotCompleted ));

   170     if ( iMessage.Handle())

   171         {

   172         iMessage.Complete( KErrUnknown );

   173         iMessage = RMessage2();

   174         }

   175     iMessage = aMessage;

   176 

   177     // clean up possible trash

   178     if (iBitmapHandle)

   179         {

   180         Server()->DeleteBitmapFromPool( iBitmapHandle );

   181         iBitmapHandle = 0;

   182         }

   183     delete iBitmap;

   184     iBitmap = NULL;

   185     delete iBuffer;

   186     iBuffer = NULL;

   187     iOriginalSize = TSize();

   188     

   189     TInt ret = KErrNone;

   190 

   191     TRAPD( err, 

   192         {

   193         ret = DispatchMessageL( aMessage ); 

   194         }

   195      );

   196     if ( iMessage.Handle())

   197         {

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

   199         iMessage = RMessage2();

   200         }

   201     else

   202     	{

   203     	return;

   204     	}

   205     }

   206 

   207 

   208 // -----------------------------------------------------------------------------

   209 // CThumbnailServerSession::Server()

   210 // Returns the server pointer.

   211 // -----------------------------------------------------------------------------

   212 //

   213 CThumbnailServer* CThumbnailServerSession::Server()

   214     {

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

   216     }

   217 

   218 

   219 // -----------------------------------------------------------------------------

   220 // CThumbnailServerSession::Cancel()

   221 // -----------------------------------------------------------------------------

   222 //

   223 void CThumbnailServerSession::Cancel()

   224     {

   225     }

   226 

   227 

   228 // -----------------------------------------------------------------------------

   229 // CThumbnailServerSession::UpdateThumbnailsL()

   230 // -----------------------------------------------------------------------------

   231 //

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

   233     {

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

   235     

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

   237        {

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

   239        User::Leave(KErrArgument);

   240        }

   241     

   242     // read message params

   243     aMessage.ReadL( 0, iRequestParams );

   244     const TThumbnailRequestParams& params = iRequestParams();

   245     

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

   247     

   248     if (finished)

   249         {

   250         TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished" );

   251         

   252         aMessage.Complete( KErrNone );

   253         }

   254     else

   255         {

   256         TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - need to recreate thumbs" );

   257         

   258         // need to create new thumbs

   259         aMessage.Complete( KThumbnailErrThumbnailNotFound );

   260         }

   261     

   262     iMessage = RMessage2();

   263     }

   264 

   265 // -----------------------------------------------------------------------------

   266 // CThumbnailServerSession::RequestThumbByIdAsyncL()

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

   268 //

   269 void CThumbnailServerSession::RequestThumbByIdAsyncL( const RMessage2&

   270     aMessage )

   271     {

   272 #ifdef _DEBUG

   273     TTime aStart, aStop;

   274     aStart.UniversalTime();

   275 #endif

   276     

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

   278     

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

   280        {

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

   282        User::Leave(KErrArgument);

   283        }

   284 

   285     aMessage.ReadL( 0, iRequestParams );

   286     const TThumbnailRequestParams& params = iRequestParams();

   287     TRAPD( err, Server()->FetchThumbnailL( params.iThumbnailId, iBitmap, iBuffer,

   288                                            params.iThumbnailSize, iOriginalSize ));

   289     if ( !err && iBitmap )

   290         {

   291         TN_DEBUG1( 

   292             "CThumbnailServerSession::RequestThumbByIdAsyncL() - found existing thumbnail- bitmap" );

   293 

   294         ProcessBitmapL();

   295         }

   296     else if ( !err && iBuffer)

   297         {

   298         TN_DEBUG1( 

   299              "CThumbnailServerSession::RequestThumbByIdAsyncL() - found existing thumbnail- jpeg" );

   300         

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

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

   303         

   304         CleanupStack::PushL( task );

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

   306         Server()->QueueTaskL( task );

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

   308         

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

   310         iMessage = RMessage2();

   311         

   312         //CThumbnailDecodeTask is responsible freeing

   313         iBuffer = NULL;

   314         }

   315     else if( err == KErrCompletion )                

   316         {

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

   318         TN_DEBUG1( 

   319             "CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail blacklisted" );

   320         aMessage.Complete( err );

   321         iMessage = RMessage2();

   322         }

   323     else                

   324         {

   325         TN_DEBUG2( 

   326             "CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail not found ( query path from MDS ), err=%d ", err );

   327 

   328 #ifdef RD_MDS_2_5        

   329         // try to query path from MDS

   330         CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(

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

   332         

   333         CleanupStack::PushL( task );

   334         task->QueryPathByIdL(params.iThumbnailId);

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

   336         Server()->QueueTaskL( task );

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

   338         

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

   340         iMessage = RMessage2();

   341 #else

   342         User::Leave(KThumbnailErrThumbnailNotFound);

   343 #endif // RD_MDS_2_5

   344         

   345         }   

   346     

   347 #ifdef _DEBUG

   348     aStop.UniversalTime();

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

   350 #endif 

   351     

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

   353     }

   354 

   355 // -----------------------------------------------------------------------------

   356 // CThumbnailServerSession::RequestThumbByFileHandleAsync()

   357 // -----------------------------------------------------------------------------

   358 //

   359 void CThumbnailServerSession::RequestThumbByFileHandleAsyncL( const RMessage2&

   360     aMessage )

   361     {

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

   363     

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

   365        {

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

   367        User::Leave(KErrArgument);

   368        }

   369     

   370     aMessage.ReadL( 0, iRequestParams );

   371     const TThumbnailRequestParams& params = iRequestParams();

   372 

   373     RFile64 file;

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

   375     

   376     ResolveMimeTypeL(&file);

   377     

   378     if(params.iThumbnailSize == EFullScreenThumbnailSize ||

   379        params.iThumbnailSize == EGridThumbnailSize ||

   380        params.iThumbnailSize == EListThumbnailSize )

   381         {

   382         TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

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

   384         ModifyThumbnailSize(sourceType);

   385         }

   386     

   387     // CreateThumbnails

   388     if (params.iControlFlags == EThumbnailGeneratePersistentSizesOnly)

   389         {

   390         CleanupClosePushL( file );

   391         CreateGenerateTaskFromFileHandleL( &file );

   392         CleanupStack::Pop( &file );         

   393         }

   394     // single thumbnail request

   395     else

   396         {

   397         TRAPD( err, FetchThumbnailL());

   398         

   399         if ( !err && iBitmap )

   400             {

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

   402 

   403             // Thumbnail already stored

   404             file.Close();

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

   406 

   407             ProcessBitmapL();

   408             }

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

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

   411             {

   412             CreateGenerateTaskFromFileHandleL( &file);

   413             }

   414         else if (!err && iBuffer)

   415             {

   416             TN_DEBUG1( 

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

   418             

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

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

   421             

   422             CleanupStack::PushL( task );

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

   424             Server()->QueueTaskL( task );

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

   426             

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

   428             iMessage = RMessage2();

   429             

   430             //CThumbnailDecodeTask is responsible freeing

   431             iBuffer = NULL;

   432             file.Close();

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

   434             }

   435         else

   436             {

   437             TN_DEBUG2( 

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

   439             aMessage.Complete( ConvertSqlErrToE32Err( err ));

   440             iMessage = RMessage2();

   441             }     

   442         }

   443     }

   444 

   445 // -----------------------------------------------------------------------------

   446 // CThumbnailServerSession::RequestThumbByPathAsync()

   447 // -----------------------------------------------------------------------------

   448 //

   449 void CThumbnailServerSession::RequestThumbByPathAsyncL( const RMessage2&

   450     aMessage )

   451     {

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

   453     

   454 #ifdef _DEBUG

   455     TTime aStart, aStop;

   456     aStart.UniversalTime();

   457 #endif

   458     

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

   460        {

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

   462        User::Leave(KErrArgument);

   463        }

   464 

   465     aMessage.ReadL( 0, iRequestParams );

   466     const TThumbnailRequestParams& params = iRequestParams();

   467     

   468     ResolveMimeTypeL(NULL);

   469     

   470     if(params.iThumbnailSize == EFullScreenThumbnailSize ||

   471        params.iThumbnailSize == EGridThumbnailSize ||

   472        params.iThumbnailSize == EListThumbnailSize )

   473         {

   474         TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

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

   476         ModifyThumbnailSize(sourceType);

   477         }

   478     

   479     // should always be true

   480     if (params.iControlFlags != EThumbnailGeneratePersistentSizesOnly)

   481 		{

   482 	    TRAPD( err, FetchThumbnailL());

   483 	    

   484 	    if ( !err && iBitmap )

   485 	        {

   486 	        TN_DEBUG1( 

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

   488 

   489 	        ProcessBitmapL();

   490 	        }

   491 	    else if ( !err && iBuffer)

   492 	        {

   493 	        TN_DEBUG1( 

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

   495 	        

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

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

   498 	        

   499 	        CleanupStack::PushL( task );

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

   501 	        Server()->QueueTaskL( task );

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

   503 	        

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

   505 	        iMessage = RMessage2();

   506 	        

   507 	        //CThumbnailDecodeTask is responsible freeing

   508 	        iBuffer = NULL;

   509 	        }

   510 	    else if( err == KErrCompletion )

   511 	        {

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

   513             TN_DEBUG1( 

   514                 "CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail blacklisted" );

   515             aMessage.Complete( err );

   516             iMessage = RMessage2();

   517 	        }

   518 	    else 

   519 	        {

   520 	        TN_DEBUG2( 

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

   522 	        

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

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

   525 	            {

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

   527 	            // and retry the request using file handle

   528 	            err = KThumbnailErrThumbnailNotFound;

   529 	            }

   530 	        else

   531 	            {

   532                 User::Leave(err);

   533                 }

   534 

   535 #ifdef RD_MDS_2_5	        

   536             // try to query ID from MDS

   537             CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(

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

   539             

   540             CleanupStack::PushL( task );

   541             task->SetUpdateToDb( EFalse );

   542             task->QueryIdByPathL( params.iFileName );

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

   544             Server()->QueueTaskL( task );

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

   546             

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

   548             iMessage = RMessage2();	            

   549 #else

   550             User::Leave(err);

   551 #endif // RD_MDS_2_5

   552 	        

   553 	        }   

   554 	   }

   555     

   556 #ifdef _DEBUG

   557     aStop.UniversalTime();

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

   559 #endif

   560     }   

   561     

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

   563     {

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

   565     

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

   567         {

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

   569         User::Leave(KErrArgument);

   570         }

   571       

   572     aMessage.ReadL( 0, iRequestParams );

   573     const TThumbnailRequestParams& params = iRequestParams();

   574     

   575     if(params.iThumbnailSize != EUnknownThumbnailSize)

   576         {

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

   578         }

   579     

   580     if(params.iThumbnailSize == EFullScreenThumbnailSize ||

   581        params.iThumbnailSize == EGridThumbnailSize ||

   582        params.iThumbnailSize == EListThumbnailSize )

   583        {

   584        TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

   585        TDataType mimetype;

   586        Server()->MimeTypeFromFileExt( params.iTargetUri, mimetype );

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

   588        ModifyThumbnailSize(sourceType);

   589        }

   590     

   591     TInt bufferSize = aMessage.Int2();

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

   593     TPtr8 ptr = buffer->Des();

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

   595     

   596     CreateGenerateTaskFromBufferL( buffer );

   597     CleanupStack::Pop( buffer );

   598     }

   599 

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

   601     {

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

   603 

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

   605         {

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

   607         User::Leave(KErrArgument);

   608         }

   609         

   610     aMessage.ReadL( 0, iRequestParams );

   611     const TThumbnailRequestParams& params = iRequestParams();

   612     

   613     TInt bitmapHandle = aMessage.Int1();

   614     TThumbnailServerRequestId &reqId = (TThumbnailServerRequestId&)params.iRequestId;

   615     

   616     // get bitmap

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

   618     CleanupStack::PushL( bitmap );

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

   620     Server()->AddBitmapToPoolL( reqId.iSession, bitmap );

   621     CleanupStack::Pop( bitmap );

   622     iBitmapHandle = bitmap->Handle();

   623     

   624     RArray < TThumbnailPersistentSize >* missingSizes = NULL;

   625     

   626     // source type

   627     TDataType mimeType;

   628     TInt sourceType = 0;

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

   630     TBool missingIDs(EFalse);

   631     

   632     // get missing sizes

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

   634         {

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

   636         

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

   638         CleanupClosePushL( *missingSizes );

   639     

   640         Server()->GetMissingSizesAndIDsL( params.iTargetUri, sourceType, *missingSizes, missingIDs);

   641             

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

   643             {

   644             // all thumbs already exist

   645             CleanupStack::PopAndDestroy( missingSizes );

   646             delete missingSizes;

   647             missingSizes = NULL;

   648             }            

   649         }

   650     

   651     // if missing sizes, create scale tasks

   652     if ( missingSizes )

   653         {

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

   655         

   656         TSize bitmapSize = bitmap->SizeInPixels();

   657         

   658         for ( TInt i( 0 ); i < count; i++ )

   659             {           

   660             if( bitmapSize.iWidth < bitmapSize.iHeight )

   661                {

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

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

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

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

   666                }

   667             

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

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

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

   671                 KMaxPriority, KNullDesC, (*missingSizes)[i].iType, params.iThumbnailId, EFalse, EFalse );

   672             CleanupStack::PushL( scaleTask );

   673             scaleTask->SetDoStore( ETrue );

   674             //increase priority, scale needs to run before ID update below

   675             scaleTask->SetPriority( params.iPriority + 1 );

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

   677             CleanupStack::Pop( scaleTask );

   678             

   679             if( i == count-1 )

   680                 {

   681                 // scaleTask is now responsible for completing the RMessage

   682                 scaleTask->SetMessageData( reqId, iMessage );

   683                 iMessage = RMessage2();

   684                 }

   685             }

   686         

   687         TN_DEBUG3("CThumbnailServerSession::RequestSetThumbnailByBitmapL() ID = %d, missingIDs = %d", params.iThumbnailId, missingIDs);

   688         }

   689     else

   690         {

   691         // complete message

   692         aMessage.Complete( KErrNone );

   693         iMessage = RMessage2();

   694         }

   695     

   696     if ( missingSizes )

   697         {

   698         CleanupStack::PopAndDestroy( missingSizes );

   699         delete missingSizes;

   700         missingSizes = NULL;

   701         }

   702     

   703     Server()->DeleteBitmapFromPool( iBitmapHandle );

   704     iBitmapHandle = 0;

   705     bitmap = NULL;

   706     }

   707 

   708 // -----------------------------------------------------------------------------

   709 // CThumbnailServerSession::CreateThumbnailsL()

   710 // Create thumbnails for given object file

   711 // -----------------------------------------------------------------------------

   712 //

   713 void CThumbnailServerSession::CreateThumbnailsL( const RMessage2& aMessage )

   714     {

   715     RFile64 file;

   716     CleanupClosePushL( file );

   717 	User::LeaveIfError( file.AdoptFromClient( aMessage, 1, 2 ));

   718 

   719 	CreateGenerateTaskFromFileHandleL( &file);

   720         

   721 	CleanupStack::Pop( &file );

   722     }      

   723 

   724  

   725 // -----------------------------------------------------------------------------

   726 // CThumbnailServerSession::CreateGenerateTaskL()

   727 // Create a task to generate a new thumbnail

   728 // -----------------------------------------------------------------------------

   729 //

   730 void CThumbnailServerSession::CreateGenerateTaskFromFileHandleL( RFile64* aFile)

   731     {

   732     const TThumbnailRequestParams& params = iRequestParams();

   733 

   734     TN_DEBUG2( 

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

   736       

   737     TBool missingIDs = EFalse;

   738     

   739     RArray < TThumbnailPersistentSize >* missingSizes = NULL;

   740     

   741     // get missing sizes

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

   743         {

   744         TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

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

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

   747         CleanupClosePushL( *missingSizes );

   748         

   749         Server()->GetMissingSizesAndIDsL( params.iFileName, sourceType, *missingSizes, missingIDs );

   750 #ifdef RD_MDS_2_5        

   751         if( missingIDs )

   752             {

   753             TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() some IDs missing");

   754             

   755             if( params.iThumbnailId == KNoId)

   756                 {

   757                 TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() query fro MDS");

   758                 // try to query ID from MDS

   759                 CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(

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

   761                 

   762                 CleanupStack::PushL( task );

   763                 task->QueryIdByPathL( params.iFileName );

   764                 

   765                 task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ) );

   766                 Server()->QueueTaskL( task );

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

   768                 TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() query from MDS queued" );

   769                 }

   770             else

   771                 {

   772                 TN_DEBUG2("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() got ID %d from params", params.iThumbnailId);

   773                 TRAP_IGNORE( Server()->UpdateIDL(params.iFileName, params.iThumbnailId ) );

   774                 }

   775             }

   776 #endif // RD_MDS_2_5

   777         

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

   779             {

   780             // all thumbs already exist

   781             CleanupStack::PopAndDestroy( missingSizes );

   782             delete missingSizes;

   783             if( aFile )

   784                {

   785                aFile->Close();

   786                }

   787             return;

   788             }            

   789         }

   790     

   791     // priority

   792     TInt priority = params.iPriority;

   793     if ( priority > KMaxGeneratePriority )

   794         {

   795         priority = KMaxGeneratePriority;

   796         }

   797     

   798     // create new task

   799     if( !aFile)

   800         {

   801         User::Leave( KErrArgument );

   802         }

   803     CleanupClosePushL( *aFile );

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

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

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

   807         params.iThumbnailSize, params.iThumbnailId, params.iQualityPreference );

   808 

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

   810     if( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly )

   811         {

   812         task->ScaledBitmapToPool( EFalse );

   813         }

   814         

   815     CleanupStack::Pop( aFile );

   816     

   817     CleanupStack::PushL( task );

   818     task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ),

   819         iMessage );

   820     Server()->QueueTaskL( task );

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

   822     

   823     if ( missingSizes )

   824         {

   825         CleanupStack::Pop( missingSizes );

   826         }

   827 

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

   829     iMessage = RMessage2();

   830     } 

   831 // -----------------------------------------------------------------------------

   832 // CThumbnailServerSession::CreateGenerateTaskL()

   833 // Create a task to generate a new thumbnail

   834 // -----------------------------------------------------------------------------

   835 //

   836 void CThumbnailServerSession::CreateGenerateTaskFromBufferL( TDesC8* aBuffer )

   837     {

   838     const TThumbnailRequestParams& params = iRequestParams();

   839 

   840     TN_DEBUG2( 

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

   842   

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

   844         {

   845         User::Leave( KErrNotSupported );

   846         }

   847     

   848     TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

   849     

   850     TDataType mimetype;

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

   852     if(ret == KErrNotFound)

   853         {

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

   855         RFile64 file;

   856         CleanupClosePushL( file );

   857         

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

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

   860                 

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

   862                 

   863         file.Close();

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

   865         

   866         CleanupStack::Pop( &file );    

   867         }

   868         

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

   870     

   871     RArray < TThumbnailPersistentSize >* missingSizes = NULL;

   872     

   873     // get missing sizes

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

   875         {

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

   877         CleanupClosePushL( *missingSizes );

   878         

   879         TBool missingIDs;

   880         Server()->GetMissingSizesAndIDsL( params.iTargetUri, sourceType, *missingSizes, missingIDs );

   881             

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

   883             {

   884             // all thumbs already exist

   885             CleanupStack::PopAndDestroy( missingSizes );

   886             delete missingSizes;

   887             if ( aBuffer)

   888                {

   889                delete aBuffer;

   890                aBuffer = NULL; 

   891                }

   892             return;

   893             }            

   894         }

   895     

   896     // priority

   897     TInt priority = params.iPriority;

   898     if ( priority > KMaxGeneratePriority )

   899         {

   900         priority = KMaxGeneratePriority;

   901         }

   902     

   903     // create new task

   904     if( !aBuffer)

   905         {

   906         User::Leave( KErrArgument );

   907         }

   908     

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

   910         ->Processor(), * Server(), NULL, aBuffer, &params.iMimeType, params.iFlags,

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

   912         params.iThumbnailSize, params.iThumbnailId, params.iQualityPreference );

   913 

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

   915     if( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly )

   916         {

   917         task->ScaledBitmapToPool( EFalse );

   918         }  

   919     

   920     CleanupStack::PushL( task );

   921     task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ),

   922         iMessage );

   923     Server()->QueueTaskL( task );

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

   925     

   926     if ( missingSizes )

   927         {

   928         CleanupStack::Pop( missingSizes );

   929         }

   930 

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

   932     iMessage = RMessage2();

   933     } 

   934 // -----------------------------------------------------------------------------

   935 // CThumbnailServerSession::FetchThumbnailL()

   936 // Fetch thumbnail data from database

   937 // -----------------------------------------------------------------------------

   938 //

   939 void CThumbnailServerSession::FetchThumbnailL()

   940     {

   941     TN_DEBUG1("CThumbnailServerSession::FetchThumbnailL()");

   942     __ASSERT_DEBUG( !iBitmap, ThumbnailPanic( EThumbnailBitmapNotReleased ));

   943 

   944     delete iBitmap;

   945     iBitmap = NULL;

   946 

   947     TThumbnailRequestParams& params = iRequestParams();

   948     

   949     if ( params.iThumbnailSize != EUnknownThumbnailSize &&

   950          params.iThumbnailSize != ECustomThumbnailSize )

   951         {

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

   953         params.iSize = persistentSize.iSize;

   954         }

   955     

   956     if( params.iFileName != KNullDesC )

   957         {

   958         TN_DEBUG4( "CThumbnailServerSession::FetchThumbnailL( TNId==%d ThumbnailSize=%d ( Path=%S ))", 

   959                 params.iThumbnailId, params.iThumbnailSize, &params.iFileName );

   960         Server()->FetchThumbnailL( params.iFileName, iBitmap, iBuffer, params.iThumbnailSize, iOriginalSize);

   961         }

   962     else

   963         {

   964         TN_DEBUG3( "CThumbnailServerSession::FetchThumbnailL(Path=%S ThumbnailSize=%d)", 

   965                         &params.iFileName, params.iThumbnailSize );

   966         Server()->FetchThumbnailL( params.iThumbnailId, iBitmap, iBuffer,  params.iThumbnailSize, iOriginalSize );

   967         }

   968 #ifdef _DEBUG

   969     if( iBitmap)

   970         {

   971         TN_DEBUG4( "CThumbnailServerSession::FetchThumbnailL() size %d x %d displaymode %d", iBitmap->SizeInPixels().iWidth, iBitmap->SizeInPixels().iHeight, iBitmap->DisplayMode());

   972         }

   973 #endif

   974     }

   975 

   976 // -----------------------------------------------------------------------------

   977 // CThumbnailServerSession::ProcessBitmapL()

   978 // Process a fetched bitmap by creating scale tasks or by returning the

   979 // bitmap as such.

   980 // -----------------------------------------------------------------------------

   981 //

   982 void CThumbnailServerSession::ProcessBitmapL()

   983     {   

   984     TThumbnailRequestParams& params = iRequestParams();

   985     

   986     // in import case store bitmap

   987     if (params.iTargetUri != KNullDesC)

   988         {

   989         Server()->StoreThumbnailL( params.iTargetUri, iBitmap, iOriginalSize,

   990                                    params.iFlags& CThumbnailManager::ECropToAspectRatio, params.iThumbnailSize, params.iThumbnailId );

   991         }

   992     

   993     // No need to scale, return iBitmap directly

   994     Server()->AddBitmapToPoolL( this, iBitmap );

   995     CFbsBitmap* bitmap = iBitmap;

   996     iBitmap = NULL; // owned by server now

   997     

   998     params.iBitmapHandle = bitmap->Handle();

   999     const TSize bitmapSize = bitmap->SizeInPixels();

  1000 

  1001     if ( params.iQualityPreference == CThumbnailManager

  1002         ::EOptimizeForQualityWithPreview && bitmapSize.iWidth <

  1003         params.iSize.iWidth && bitmapSize.iHeight < params.iSize.iHeight &&

  1004         bitmapSize.iWidth < iOriginalSize.iWidth && bitmapSize.iHeight <

  1005         iOriginalSize.iHeight )

  1006         {

  1007         // This is a non-scaled preview bitmap

  1008         params.iControlFlags = EThumbnailPreviewThumbnail;

  1009         }

  1010 

  1011     if ( iMessage.Handle() )

  1012         {

  1013         iMessage.WriteL( 0, iRequestParams );

  1014         iMessage.Complete( KErrNone );

  1015         iMessage = RMessage2();

  1016         }            

  1017     }

  1018 

  1019 // -----------------------------------------------------------------------------

  1020 // CThumbnailServerSession::ReleaseBitmap()

  1021 // Release bitmap from bitmap pool

  1022 // -----------------------------------------------------------------------------

  1023 //

  1024 void CThumbnailServerSession::ReleaseBitmap( const RMessage2& aMessage )

  1025     {

  1026     TN_DEBUG2( "CThumbnailServerSession::ReleaseBitmap(%d)", aMessage.Int0());

  1027     Server()->DeleteBitmapFromPool( aMessage.Int0());

  1028     }

  1029 

  1030 

  1031 // -----------------------------------------------------------------------------

  1032 // CThumbnailServerSession::CancelRequest()

  1033 // Cancel pending request.

  1034 // -----------------------------------------------------------------------------

  1035 //

  1036 TInt CThumbnailServerSession::CancelRequest( const RMessage2& aMessage )

  1037     {

  1038     const TThumbnailServerRequestId requestId( this, aMessage.Int0());

  1039     const TInt err = Server()->DequeTask( requestId );

  1040     TN_DEBUG4( 

  1041         "CThumbnailServerSession::CancelRequest(0x%08x/%d) - returning %d",

  1042         requestId.iSession, requestId.iRequestId, err );

  1043     return err;

  1044     }

  1045 

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

  1047 // CThumbnailServerSession::ChangePriority()

  1048 // Change priority of pending request.

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

  1050 //

  1051 TInt CThumbnailServerSession::ChangePriority( const RMessage2& aMessage )

  1052     {

  1053     const TThumbnailServerRequestId requestId( this, aMessage.Int0());

  1054     const TInt newPriority = aMessage.Int1();

  1055 

  1056     const TInt err = Server()->ChangeTaskPriority( requestId, newPriority );

  1057     TN_DEBUG5( 

  1058         "CThumbnailServerSession::ChangePriority(0x%08x/%d, %d) - returning %d",

  1059         requestId.iSession, requestId.iRequestId, newPriority, err );

  1060     return err;

  1061     }

  1062 

  1063 // -----------------------------------------------------------------------------

  1064 // CThumbnailServerSession::DeleteThumbnailsL()

  1065 // Delete thumbnails for given object file

  1066 // -----------------------------------------------------------------------------

  1067 //

  1068 void CThumbnailServerSession::DeleteThumbnailsL( const RMessage2& aMessage )

  1069     {

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

  1071        {

  1072        TN_DEBUG1( "CThumbnailServerSession::DeleteThumbnailsL() - error in aMessage - leaving" );

  1073        User::Leave(KErrArgument);

  1074        }

  1075     

  1076     HBufC* fileName = HBufC::NewLC( KMaxFileName );

  1077     TPtr ptr = fileName->Des();

  1078     aMessage.ReadL( 1, ptr );

  1079     Server()->DeleteThumbnailsL( ptr );

  1080     CleanupStack::PopAndDestroy( fileName );

  1081     

  1082     aMessage.Complete( KErrNone );

  1083     iMessage = RMessage2();

  1084     }

  1085 

  1086 // -----------------------------------------------------------------------------

  1087 // CThumbnailServerSession::DeleteThumbnailsByIdL()

  1088 // Delete thumbnails by TThumbnailId.

  1089 // -----------------------------------------------------------------------------

  1090 //

  1091 void CThumbnailServerSession::DeleteThumbnailsByIdL( const RMessage2& aMessage )

  1092     {

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

  1094        {

  1095        TN_DEBUG1( "CThumbnailServerSession::DeleteThumbnailsByIdL() - error in aMessage - leaving" );

  1096        User::Leave(KErrArgument);

  1097        }

  1098     

  1099     // read message params

  1100     aMessage.ReadL( 0, iRequestParams );

  1101     const TThumbnailRequestParams& params = iRequestParams();

  1102     

  1103     TThumbnailId id = params.iThumbnailId;

  1104     Server()->DeleteThumbnailsByIdL( id );

  1105     

  1106     aMessage.Complete( KErrNone );

  1107     iMessage = RMessage2();

  1108     }

  1109 

  1110 // -----------------------------------------------------------------------------

  1111 // Get the required size (in characters) for a buffer that contains the

  1112 // list of supported MIME types

  1113 // -----------------------------------------------------------------------------

  1114 //

  1115 void CThumbnailServerSession::GetMimeTypeBufferSizeL( const RMessage2& aMessage

  1116     )

  1117     {

  1118     TPckgBuf < TInt > buf;

  1119     buf() = Server()->GetMimeTypeBufferSize();

  1120     aMessage.WriteL( 0, buf );

  1121     }

  1122 

  1123 // -----------------------------------------------------------------------------

  1124 // Get the list of supported MIME types and store them in the buffer

  1125 // allocated by the client.

  1126 // -----------------------------------------------------------------------------

  1127 //

  1128 void CThumbnailServerSession::GetMimeTypeListL( const RMessage2& aMessage )

  1129     {

  1130     TInt len = aMessage.GetDesMaxLengthL( 0 );

  1131     HBufC* buf = HBufC::NewLC( len );

  1132     TPtr ptr = buf->Des();

  1133     Server()->GetMimeTypeList( ptr );

  1134     aMessage.WriteL( 0, * buf );