FCL/sf/mw/imghandling: comparison imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserversession.cpp

equal deleted inserted replaced

-:82749d516180
+:2eb74cf6572e
 case EChangePriority:
 {
 err = ChangePriority( aMessage );
 break;
 }
-case ECreateThumbnails:
-{
-CreateThumbnailsL( aMessage );
-break;
-}
 case EDeleteThumbnails:
 {
 DeleteThumbnailsL( aMessage );
 break;
 }
 // read message params
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
-TBool finished = Server()->UpdateThumbnailsL( params.iThumbnailId, params.iFileName, params.iOrientation, params.iModified );
+TBool finished = Server()->UpdateThumbnailsL( params.iFileName, params.iOrientation, params.iModified );
 RArray < TThumbnailPersistentSize >* missingSizes = NULL;
+TBool gridSizeOnly(EFalse);
+if ( params.iQualityPreference == CThumbnailManager
+::EOptimizeForQualityWithPreview )
+{
+gridSizeOnly = ETrue;
+}
 if (finished)
 {
 // source type
 TDataType mimeType;
 TInt sourceType = 0;
 TInt err = Server()->MimeTypeFromFileExt( params.iFileName, mimeType );
-TBool missingIDs(EFalse);
 // get missing sizes
 if ( err == KErrNone && ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )
 {
 sourceType = Server()->SourceTypeFromMimeType( mimeType );
 missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;
 CleanupClosePushL( *missingSizes );
-Server()->GetMissingSizesAndIDsL( params.iFileName, sourceType, *missingSizes, missingIDs);
+Server()->GetMissingSizesL( params.iFileName, sourceType, *missingSizes, gridSizeOnly );
 if ( missingSizes->Count() == 0)
 {
 // all thumbs already exist
 CleanupStack::PopAndDestroy( missingSizes );
 }
 }
 if(!missingSizes)
 {
-TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished" );
+TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished part 1" );
 aMessage.Complete( KErrNone );
 }
 else
 {
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - some sizes missing..." );
 }
 }
-if(missingSizes || !finished)
+if (missingSizes || !finished)
 {
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - need to create (some) thumbs" );
 if(missingSizes)
 {
 // need to create new thumbs
 aMessage.Complete( KThumbnailErrThumbnailNotFound );
 }
 else
 {
-TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished" );
+TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished part 2" );
 }
 iMessage = RMessage2();
 }
 User::Leave(KErrArgument);
 }
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
-TRAPD( err, Server()->FetchThumbnailL( params.iThumbnailId, iBitmap, iBuffer,
-params.iThumbnailSize, iOriginalSize ));
-if ( !err && iBitmap )
-{
-TN_DEBUG1(
-"CThumbnailServerSession::RequestThumbByIdAsyncL() - found existing thumbnail- bitmap" );
-ProcessBitmapL();
-}
-else if ( !err && iBuffer)
-{
-TN_DEBUG1(
-"CThumbnailServerSession::RequestThumbByIdAsyncL() - found existing thumbnail- jpeg" );
-CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()
-->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );
-CleanupStack::PushL( task );
-task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage );
-Server()->QueueTaskL( task );
-CleanupStack::Pop( task ); // owned by processor now
-// Decode task is now responsible for completing the message
-iMessage = RMessage2();
-//CThumbnailDecodeTask is responsible freeing
-iBuffer = NULL;
-}
-else if( err == KErrCompletion )
-{
-// If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion
-TN_DEBUG1(
-"CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail blacklisted" );
-aMessage.Complete( err );
-iMessage = RMessage2();
-}
-else
-{
-TN_DEBUG2(
-"CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail not found ( query path from MDS ), err=%d ", err );
 #ifdef RD_MDS_2_5
 // try to query path from MDS
 CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(
 Server()->Processor(), params.iPriority + 1, Server()->GetMdESession(), *Server());
 CleanupStack::PushL( task );
-task->QueryPathByIdL(params.iThumbnailId);
+task->QueryPathByIdL(params.iThumbnailId, EFalse);
 task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage );
 Server()->QueueTaskL( task );
 CleanupStack::Pop( task ); // owned by processor now
 // query task is now responsible for completing the message
 iMessage = RMessage2();
 #else
-User::Leave(KThumbnailErrThumbnailNotFound);
+User::Leave(KErrNotSupported);
 #endif // RD_MDS_2_5
-}
 #ifdef _DEBUG
 aStop.UniversalTime();
-TN_DEBUG2( "CThumbnailStore::RequestThumbByIdAsyncL() request took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000 );
+TN_DEBUG2( "CThumbnailServerSession::RequestThumbByIdAsyncL() request took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000 );
 #endif
 TN_DEBUG1("CThumbnailServerSession::RequestThumbByIdAsyncL() - end" );
 }
 }
 // CreateThumbnails
 if (params.iControlFlags == EThumbnailGeneratePersistentSizesOnly)
 {
+TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - EThumbnailGeneratePersistentSizesOnly" );
 CleanupClosePushL( file );
 CreateGenerateTaskFromFileHandleL( &file );
 CleanupStack::Pop( &file );
 }
 // single thumbnail request
 ProcessBitmapL();
 }
 else if ( (err == KErrNotFound || err == KErrAccessDenied) &&
 !(params.iFlags& CThumbnailManager::EDoNotCreate) )
 {
+TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - KErrNotFound & !EDoNotCreate" );
 CreateGenerateTaskFromFileHandleL( &file);
 }
 else if (!err && iBuffer)
 {
 TN_DEBUG1(
 	        }
 	    else if( err == KErrCompletion )
 	        {
 // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion
 TN_DEBUG1(
-"CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail blacklisted" );
+"CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail blacklisted" );
 aMessage.Complete( err );
 iMessage = RMessage2();
 	        }
 	    else
 	        {
 	        if(Server()->StoreForPathL(params.iFileName)->IsDiskFull())
 	            {
 	            User::Leave( KErrDiskFull );
 	            }
-#ifdef RD_MDS_2_5
-// try to query ID from MDS
-CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(
-Server()->Processor(), params.iPriority + 1, Server()->GetMdESession(), *Server());
-CleanupStack::PushL( task );
-task->SetUpdateToDb( EFalse );
-task->QueryIdByPathL( params.iFileName );
-task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage );
-Server()->QueueTaskL( task );
-CleanupStack::Pop( task ); // owned by processor now
-// query task is now responsible for completing the message
-iMessage = RMessage2();
-#else
 User::Leave(err);
-#endif // RD_MDS_2_5
 	        }
 	   }
 #ifdef _DEBUG
 aStop.UniversalTime();
 // source type
 TDataType mimeType;
 TInt sourceType = 0;
 TInt err = Server()->MimeTypeFromFileExt( params.iTargetUri, mimeType );
-TBool missingIDs(EFalse);
 // get missing sizes
 if ( err == KErrNone && ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )
 {
 sourceType = Server()->SourceTypeFromMimeType( mimeType );
 missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;
 CleanupClosePushL( *missingSizes );
-Server()->GetMissingSizesAndIDsL( params.iTargetUri, sourceType, *missingSizes, missingIDs);
+Server()->GetMissingSizesL( params.iTargetUri, sourceType, *missingSizes, EFalse);
 if ( missingSizes->Count() == 0)
 {
 // all thumbs already exist
 CleanupStack::PopAndDestroy( missingSizes );
 }
 CThumbnailScaleTask* scaleTask = CThumbnailScaleTask::NewL( Server()->Processor(),
 *Server(), params.iTargetUri, bitmap, bitmapSize,
 (*missingSizes)[i].iSize, (*missingSizes)[i].iCrop, params.iDisplayMode,
-KMaxPriority, KNullDesC, (*missingSizes)[i].iType, params.iThumbnailId, EFalse, EFalse );
+KMaxPriority, KNullDesC, (*missingSizes)[i].iType, params.iModified, EFalse, EFalse );
 CleanupStack::PushL( scaleTask );
 scaleTask->SetDoStore( ETrue );
-//increase priority, scale needs to run before ID update below
-scaleTask->SetPriority( params.iPriority + 1 );
 Server()->Processor().AddTaskL( scaleTask );
 CleanupStack::Pop( scaleTask );
 if( i == count-1 )
 {
 // scaleTask is now responsible for completing the RMessage
 scaleTask->SetMessageData( reqId, iMessage );
 iMessage = RMessage2();
 }
 }
-TN_DEBUG3("CThumbnailServerSession::RequestSetThumbnailByBitmapL() ID = %d, missingIDs = %d", params.iThumbnailId, missingIDs);
 }
 else
 {
 // complete message
 aMessage.Complete( KErrNone );
 Server()->DeleteBitmapFromPool( iBitmapHandle );
 iBitmapHandle = 0;
 bitmap = NULL;
 }
-// -----------------------------------------------------------------------------
-// CThumbnailServerSession::CreateThumbnailsL()
-// Create thumbnails for given object file
-// -----------------------------------------------------------------------------
-//
-void CThumbnailServerSession::CreateThumbnailsL( const RMessage2& aMessage )
-{
-RFile64 file;
-CleanupClosePushL( file );
-	User::LeaveIfError( file.AdoptFromClient( aMessage, 1, 2 ));
-	CreateGenerateTaskFromFileHandleL( &file);
-	CleanupStack::Pop( &file );
-}
 // -----------------------------------------------------------------------------
 // CThumbnailServerSession::CreateGenerateTaskL()
 // Create a task to generate a new thumbnail
 // -----------------------------------------------------------------------------
 if(Server()->StoreForPathL(params.iFileName)->IsDiskFull())
 {
 User::Leave( KErrDiskFull );
 }
-TBool missingIDs = EFalse;
 RArray < TThumbnailPersistentSize >* missingSizes = NULL;
 // get missing sizes
 if ( ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )
 {
 TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;
 sourceType = Server()->SourceTypeFromMimeType( params.iMimeType );
 missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;
 CleanupClosePushL( *missingSizes );
-Server()->GetMissingSizesAndIDsL( params.iFileName, sourceType, *missingSizes, missingIDs );
-#ifdef RD_MDS_2_5
+	    TBool gridSizeOnly(EFalse);
-if( missingIDs )
-{
-TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() some IDs missing");
-if( params.iThumbnailId == KNoId)
+	    if ( params.iQualityPreference == CThumbnailManager
-{
+	                    ::EOptimizeForQualityWithPreview )
-TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() query fro MDS");
+	        {
-// try to query ID from MDS
+	        gridSizeOnly = ETrue;
-CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(
+	        }
-Server()->Processor(), params.iPriority + 1, Server()->GetMdESession(), *Server());
+Server()->GetMissingSizesL( params.iFileName, sourceType, *missingSizes, gridSizeOnly);
-CleanupStack::PushL( task );
-task->QueryIdByPathL( params.iFileName );
-task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ) );
-Server()->QueueTaskL( task );
-CleanupStack::Pop( task ); // owned by processor now
-TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() query from MDS queued" );
-}
-else
-{
-TN_DEBUG2("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() got ID %d from params", params.iThumbnailId);
-TRAP_IGNORE( Server()->UpdateIDL(params.iFileName, params.iThumbnailId ) );
-}
-}
-#endif // RD_MDS_2_5
 if ( missingSizes->Count() == 0)
 {
 // all thumbs already exist
 CleanupStack::PopAndDestroy( missingSizes );
 }
 CleanupClosePushL( *aFile );
 CThumbnailGenerateTask* task = new( ELeave )CThumbnailGenerateTask( Server()
 ->Processor(), * Server(), aFile, NULL, &params.iMimeType, params.iFlags,
 params.iSize, params.iDisplayMode, priority, missingSizes, params.iTargetUri,
-params.iThumbnailSize, params.iThumbnailId, params.iQualityPreference );
+params.iThumbnailSize, params.iModified, params.iQualityPreference );
 // do not store bitmaps to server pool when generating only
 if( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly )
 {
 task->ScaledBitmapToPool( EFalse );
 if ( ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )
 {
 missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;
 CleanupClosePushL( *missingSizes );
-TBool missingIDs;
+Server()->GetMissingSizesL( params.iTargetUri, sourceType, *missingSizes, EFalse );
-Server()->GetMissingSizesAndIDsL( params.iTargetUri, sourceType, *missingSizes, missingIDs );
 if ( missingSizes->Count() == 0)
 {
 // all thumbs already exist
 CleanupStack::PopAndDestroy( missingSizes );
 }
 CThumbnailGenerateTask* task = new( ELeave )CThumbnailGenerateTask( Server()
 ->Processor(), * Server(), NULL, aBuffer, &params.iMimeType, params.iFlags,
 params.iSize, params.iDisplayMode, priority, missingSizes, params.iTargetUri,
-params.iThumbnailSize, params.iThumbnailId, params.iQualityPreference );
+params.iThumbnailSize, params.iModified, params.iQualityPreference );
 // do not store bitmaps to server pool when generating only
 if( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly )
 {
 task->ScaledBitmapToPool( EFalse );
 params.iSize = persistentSize.iSize;
 }
 if( params.iFileName != KNullDesC )
 {
-TN_DEBUG4( "CThumbnailServerSession::FetchThumbnailL( TNId==%d ThumbnailSize=%d ( Path=%S ))",
+TN_DEBUG3( "CThumbnailServerSession::FetchThumbnailL( ThumbnailSize=%d ( Path=%S ))",
-params.iThumbnailId, params.iThumbnailSize, &params.iFileName );
+params.iThumbnailSize, &params.iFileName );
 Server()->FetchThumbnailL( params.iFileName, iBitmap, iBuffer, params.iThumbnailSize, iOriginalSize);
 }
 else
 {
-TN_DEBUG3( "CThumbnailServerSession::FetchThumbnailL(Path=%S ThumbnailSize=%d)",
+User::Leave( KErrNotSupported );
-&params.iFileName, params.iThumbnailSize );
-Server()->FetchThumbnailL( params.iThumbnailId, iBitmap, iBuffer,  params.iThumbnailSize, iOriginalSize );
 }
 #ifdef _DEBUG
 if( iBitmap)
 {
 TN_DEBUG4( "CThumbnailServerSession::FetchThumbnailL() size %d x %d displaymode %d", iBitmap->SizeInPixels().iWidth, iBitmap->SizeInPixels().iHeight, iBitmap->DisplayMode());
 if ( params.iTargetUri != KNullDesC && params.iFileName != KNullDesC &&
 params.iFileName.CompareF(params.iTargetUri) != 0 )
 {
 Server()->StoreThumbnailL( params.iTargetUri, iBitmap, iOriginalSize,
 params.iFlags& CThumbnailManager::ECropToAspectRatio,
-params.iThumbnailSize, params.iThumbnailId,
+params.iThumbnailSize, params.iModified,
 EFalse, EFalse);
 }
 if ( ClientThreadAlive(iMessage) )
 {
 // read message params
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
-TThumbnailId id = params.iThumbnailId;
-Server()->DeleteThumbnailsByIdL( id );
+#ifdef RD_MDS_2_5
+// try to query path from MDS
+CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(
+Server()->Processor(), params.iPriority + 1, Server()->GetMdESession(), *Server());
+CleanupStack::PushL( task );
+task->QueryPathByIdL(params.iThumbnailId, ETrue);
+Server()->QueueTaskL( task );
+CleanupStack::Pop( task ); // owned by processor now
+#endif // RD_MDS_2_5
 aMessage.Complete( KErrNone );
 iMessage = RMessage2();
 }
 // -----------------------------------------------------------------------------
 // RThumbnailMessage::FilterSqlErr
 // ---------------------------------------------------------------------------
 //
 TInt CThumbnailServerSession::ConvertSqlErrToE32Err( TInt aReason )
 {
+TN_DEBUG2("CThumbnailServerSession::ConvertSqlErrToE32Err(%d)", aReason);
 TInt e32Err;
 if ( aReason >=  - 144 )
 // magic: [-1..-144] is E32 error range
 {
 // E32 error value or non-negative value

branch	RCL_3
changeset 9	2eb74cf6572e
parent 5	82749d516180
child 10	7403edfcf0fb