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

equal deleted inserted replaced

-:ea43e3e86079
+:a0ee3f735f8b
 // ---------------------------------------------------------------------------
 //
 CThumbnailServerSession::~CThumbnailServerSession()
 {
 Server()->DropSession(this);
+delete iBitmap;
+iBitmap = NULL;
+delete iBuffer;
+iBuffer = NULL;
 }
 // -----------------------------------------------------------------------------
 // CThumbnailServerSession::DispatchMessageL()
 // CThumbnailServerSession::CreateL()
 // ---------------------------------------------------------------------------
 //
 void CThumbnailServerSession::CreateL()
 {
+TN_DEBUG2( "CThumbnailServerSession::AddSession() = 0x%08x", this );
 Server()->AddSession();
 }
 // -----------------------------------------------------------------------------
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
 RFile64 file;
+CleanupClosePushL(file);
 User::LeaveIfError( file.AdoptFromClient( aMessage, 2, 3 ));
 ResolveMimeTypeL(&file);
 if(params.iThumbnailSize == EFullScreenThumbnailSize ||
 TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;
 sourceType = Server()->SourceTypeFromMimeType( params.iMimeType );
 ModifyThumbnailSize(sourceType);
 }
+// delete existing
+if(params.iImport && params.iOverwrite)
+{
+Server()->DeleteThumbnailsL( params.iTargetUri);
+}
 // CreateThumbnails
 if (params.iControlFlags == EThumbnailGeneratePersistentSizesOnly)
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - EThumbnailGeneratePersistentSizesOnly" );
-CleanupClosePushL( file );
 CreateGenerateTaskFromFileHandleL( &file );
-CleanupStack::Pop( &file );
+// ownership of the file transferred
+CleanupStack::Pop(&file);
 }
 // single thumbnail request
 else
 {
 TRAPD( err, FetchThumbnailL());
 if( err == KErrCompletion )
 {
 // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion
-TN_DEBUG1(
+TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail blacklisted" );
-"CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail blacklisted" );
 aMessage.Complete( err );
 iMessage = RMessage2();
+// close file
+CleanupStack::PopAndDestroy(&file);
 }
 else if ( !err && iBitmap )
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - bitmap " );
 // Thumbnail already stored
-file.Close();
+CleanupStack::PopAndDestroy(&file);
 TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed");
 ProcessBitmapL();
 }
 else if ( (err == KErrNotFound || err == KErrAccessDenied) &&
 !(params.iFlags& CThumbnailManager::EDoNotCreate) )
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - KErrNotFound & !EDoNotCreate" );
 CreateGenerateTaskFromFileHandleL( &file);
+// ownership of the file transferred
+	CleanupStack::Pop(&file);
 }
 else if (!err && iBuffer)
 {
-TN_DEBUG1(
+TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - jpeg " );
-"CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - jpeg " );
 CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()
 ->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );
 CleanupStack::PushL( task );
 // Decode task is now responsible for completing the message
 iMessage = RMessage2();
 //CThumbnailDecodeTask is responsible freeing
 iBuffer = NULL;
-file.Close();
+// close file
+CleanupStack::PopAndDestroy(&file);
 TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed");
 }
 else
 {
-TN_DEBUG2(
+TN_DEBUG2( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail not found, err=%d", err );
-"CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail not found, err=%d", err );
 aMessage.Complete( ConvertSqlErrToE32Err( err ));
 iMessage = RMessage2();
+// close file
+CleanupStack::PopAndDestroy(&file);
 }
 }
 }
 // -----------------------------------------------------------------------------
 	        iBuffer = NULL;
 	        }
 	    else if( err == KErrCompletion )
 	        {
 // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion
-TN_DEBUG1(
+TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail blacklisted" );
-"CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail blacklisted" );
 aMessage.Complete( err );
 iMessage = RMessage2();
 	        }
 	    else
 	        {
 	        TN_DEBUG2(
 	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail not found, err = %d", err );
+	        // don't try to create from virtual URI
+	        if ( params.iVirtualUri )
+	            {
+User::Leave(err);
+	            }
+// disk space check only for stored sizes
+if ( params.iThumbnailSize != ECustomThumbnailSize &&
+Server()->StoreForPathL(params.iFileName)->IsDiskFull() )
+{
+User::Leave( KErrDiskFull );
+}
 	        if ( (err == KErrNotFound || err == KErrAccessDenied) &&
 	            !(params.iFlags& CThumbnailManager::EDoNotCreate) )
 	            {
 	            // Special error code so that the client side can open the file
 	            // and retry the request using file handle
 	            err = KThumbnailErrThumbnailNotFound;
 	            }
-	        else
-	            {
-User::Leave(err);
-}
-	        if(Server()->StoreForPathL(params.iFileName)->IsDiskFull())
-	            {
-	            User::Leave( KErrDiskFull );
-	            }
 User::Leave(err);
 	        }
 	   }
 }
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
-if(params.iThumbnailSize != EUnknownThumbnailSize)
+// delete existing
+if(params.iOverwrite)
 {
 Server()->DeleteThumbnailsL( params.iTargetUri);
 }
-if(params.iThumbnailSize == EFullScreenThumbnailSize ||
+// if only one size
-params.iThumbnailSize == EGridThumbnailSize ||
+if ((params.iControlFlags & EThumbnailGeneratePersistentSizesOnly) == 0)
-params.iThumbnailSize == EListThumbnailSize )
+{
-{
+if(params.iThumbnailSize == EFullScreenThumbnailSize ||
-TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;
+params.iThumbnailSize == EGridThumbnailSize ||
-TDataType mimetype;
+params.iThumbnailSize == EListThumbnailSize )
-TInt ret = Server()->MimeTypeFromFileExt( params.iTargetUri, mimetype );
-if( ret == KErrNone )
 {
-sourceType = Server()->SourceTypeFromMimeType( mimetype );
+TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;
-ModifyThumbnailSize(sourceType);
+TDataType mimetype;
+TInt ret = Server()->MimeTypeFromFileExt( params.iTargetUri, mimetype );
+if( ret == KErrNone )
+{
+sourceType = Server()->SourceTypeFromMimeType( mimetype );
+ModifyThumbnailSize(sourceType);
+}
+User::LeaveIfError( ret );
 }
-User::LeaveIfError( ret );
+}
-}
 TInt bufferSize = aMessage.Int2();
 HBufC8* buffer = HBufC8::NewMaxLC( bufferSize );
 TPtr8 ptr = buffer->Des();
 aMessage.ReadL( 1 /* buffer pointer */, ptr );
 }
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
+const TThumbnailServerRequestId reqId( this, params.iRequestId );
+// delete existing
+if(params.iOverwrite)
+{
+Server()->DeleteThumbnailsL( params.iTargetUri);
+}
+// if only one size
+if ((params.iControlFlags & EThumbnailGeneratePersistentSizesOnly) == 0)
+{
+if(params.iThumbnailSize == EFullScreenThumbnailSize ||
+params.iThumbnailSize == EGridThumbnailSize ||
+params.iThumbnailSize == EListThumbnailSize )
+{
+TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;
+TDataType mimetype;
+TInt ret = Server()->MimeTypeFromFileExt( params.iTargetUri, mimetype );
+if( ret == KErrNone )
+{
+sourceType = Server()->SourceTypeFromMimeType( mimetype );
+ModifyThumbnailSize(sourceType);
+}
+User::LeaveIfError( ret );
+}
+}
 TInt bitmapHandle = aMessage.Int1();
-TThumbnailServerRequestId &reqId = (TThumbnailServerRequestId&)params.iRequestId;
 // get bitmap
 CFbsBitmap* bitmap = new( ELeave )CFbsBitmap();
 CleanupStack::PushL( bitmap );
 User::LeaveIfError( bitmap->Duplicate( bitmapHandle ) );
 // use pool to prevent bitmap leak
 // this bitmap is shared to several scale tasks, one of which can Leave
-Server()->AddBitmapToPoolL( reqId.iSession, bitmap, reqId );
+Server()->AddBitmapToPoolL( this, bitmap, reqId );
 CleanupStack::Pop( bitmap );
 iBitmapHandle = bitmap->Handle();
 RArray < TThumbnailPersistentSize >* missingSizes = NULL;
 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.iModified, EFalse, EFalse,
-reqId);
+reqId, params.iVirtualUri);
 CleanupStack::PushL( scaleTask );
 scaleTask->SetDoStore( ETrue );
 Server()->Processor().AddTaskL( scaleTask );
 CleanupStack::Pop( scaleTask );
 // completion to first task, because task processor works like stack
 if( i == 0 )
 {
 // scaleTask is now responsible for completing the RMessage
 scaleTask->SetMessageData( reqId, iMessage, iClientThread );
 iMessage = RMessage2();
 }
 }
 // Create a task to generate a new thumbnail
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServerSession::CreateGenerateTaskFromFileHandleL( RFile64* aFile)
 {
-const TThumbnailRequestParams& params = iRequestParams();
+TThumbnailRequestParams& params = iRequestParams();
 TN_DEBUG2(
 "CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() -- create thumbnail generation task for %S", &params.iFileName );
-if(Server()->StoreForPathL(params.iFileName)->IsDiskFull())
+// disk space check only for stored sizes
+if ( params.iImport &&
+Server()->StoreForPathL(params.iTargetUri)->IsDiskFull() )
+{
+User::Leave( KErrDiskFull );
+}
+else if ( params.iThumbnailSize != ECustomThumbnailSize &&
+Server()->StoreForPathL(params.iFileName)->IsDiskFull() )
 {
 User::Leave( KErrDiskFull );
 }
 RArray < TThumbnailPersistentSize >* missingSizes = NULL;
 TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;
 sourceType = Server()->SourceTypeFromMimeType( params.iMimeType );
 missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;
 CleanupClosePushL( *missingSizes );
 	    TBool gridSizeOnly(EFalse);
-	    if ( params.iQualityPreference == CThumbnailManager
+	    if ( params.iQualityPreference == CThumbnailManager::EOptimizeForQualityWithPreview )
-	                    ::EOptimizeForQualityWithPreview )
 	        {
 	        gridSizeOnly = ETrue;
 	        }
-Server()->GetMissingSizesL( params.iFileName, sourceType, *missingSizes, gridSizeOnly);
+	    // import vs. normal
+	    if(params.iImport)
+	        {
+Server()->GetMissingSizesL( params.iTargetUri, sourceType, *missingSizes, gridSizeOnly);
+	        }
+	    else
+	        {
+Server()->GetMissingSizesL( params.iFileName, sourceType, *missingSizes, gridSizeOnly);
+	        }
 if ( missingSizes->Count() == 0)
 {
 // all thumbs already exist
 CleanupStack::PopAndDestroy( missingSizes );
 aFile->Close();
 }
 return;
 }
 }
+// creating single TN on demand
+else if( params.iThumbnailSize > ECustomThumbnailSize && params.iThumbnailSize  < EThumbnailSizeCount)
+{
+TThumbnailPersistentSize persistentSize = Server()->PersistentSizeL(params.iThumbnailSize);
+if(persistentSize.iCrop)
+{
+params.iFlags = ( CThumbnailManager::TThumbnailFlags ) (params.iFlags | CThumbnailManager::ECropToAspectRatio);
+}
+else
+{
+params.iFlags = ( CThumbnailManager::TThumbnailFlags ) (params.iFlags & CThumbnailManager::ECropToAspectRatio);
+}
+if( ClientThreadAlive() )
+{
+iMessage.Write( 0, iRequestParams );
+}
+}
 // priority
 TInt priority = params.iPriority;
 if ( priority > KMaxGeneratePriority )
 {
 }
 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.iModified, params.iQualityPreference );
+params.iThumbnailSize, params.iModified, params.iQualityPreference,
+params.iVirtualUri);
 // do not store bitmaps to server pool when generating only
 if( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly )
 {
 task->ScaledBitmapToPool( EFalse );
 }
 // Generate task is now responsible for completing the message
 iMessage = RMessage2();
 }
 // -----------------------------------------------------------------------------
 // CThumbnailServerSession::CreateGenerateTaskL()
 // Create a task to generate a new thumbnail
 // -----------------------------------------------------------------------------
 //
 const TThumbnailRequestParams& params = iRequestParams();
 TN_DEBUG2(
 "CThumbnailServerSession::CreateGenerateTaskFromBufferL() -- create thumbnail generation task for %S", &params.iTargetUri );
-if(Server()->StoreForPathL(params.iTargetUri)->IsDiskFull())
+// disk space check only for stored sizes
+if ( params.iThumbnailSize != ECustomThumbnailSize &&
+Server()->StoreForPathL(params.iTargetUri)->IsDiskFull() )
 {
 User::Leave( KErrDiskFull );
 }
 if(aBuffer && params.iMimeType.Des().Match( KVideoMime ) == 0 )
 }
 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.iModified, params.iQualityPreference );
+params.iThumbnailSize, params.iModified, params.iQualityPreference,
+params.iVirtualUri);
 // do not store bitmaps to server pool when generating only
 if( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly )
 {
 task->ScaledBitmapToPool( EFalse );
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServerSession::ProcessBitmapL()
 {
 TThumbnailRequestParams& params = iRequestParams();
-// in import case store bitmap
-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.iModified,
-EFalse, EFalse);
-}
 if ( ClientThreadAlive() )
 {
 TN_DEBUG2("CThumbnailServerSession::ProcessBitmapL(), iBitmap handle= 0x%08x", iBitmap->Handle());
 iMessage.WriteL( 0, iRequestParams );
 TN_DEBUG1("CThumbnailServerSession()::ProcessBitmapL() bitmap to pool");
-TThumbnailServerRequestId &reqId = (TThumbnailServerRequestId&)params.iRequestId;
+Server()->AddBitmapToPoolL( this, iBitmap, TThumbnailServerRequestId( this, params.iRequestId ) );
-Server()->AddBitmapToPoolL( this, iBitmap, reqId );
 iMessage.Complete( KErrNone );
 iMessage = RMessage2();
 iBitmap = NULL; // owned by server now
 // read message params
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
 #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);
+task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ) );
 Server()->QueueTaskL( task );
 CleanupStack::Pop( task ); // owned by processor now
 #endif // RD_MDS_2_5
 aMessage.Complete( KErrNone );
 iMessage = RMessage2();
 }
 // -----------------------------------------------------------------------------
 // Get the required size (in characters) for a buffer that contains the
 // list of supported MIME types
 // -----------------------------------------------------------------------------
 //
-void CThumbnailServerSession::GetMimeTypeBufferSizeL( const RMessage2& aMessage
+void CThumbnailServerSession::GetMimeTypeBufferSizeL( const RMessage2& aMessage )
-)
 {
 TPckgBuf < TInt > buf;
 buf() = Server()->GetMimeTypeBufferSize();
 aMessage.WriteL( 0, buf );
 }
 else if(params.iThumbnailSize == EListThumbnailSize)
 {
 params.iThumbnailSize = EAudioListThumbnailSize;
 }
 }
+else if(aSourceType == TThumbnailPersistentSize::EContact)
+{
+if(params.iThumbnailSize == EFullScreenThumbnailSize)
+{
+params.iThumbnailSize = EContactFullScreenThumbnailSize;
+}
+else if(params.iThumbnailSize == EGridThumbnailSize)
+{
+params.iThumbnailSize = EContactGridThumbnailSize;
+}
+else if(params.iThumbnailSize == EListThumbnailSize)
+{
+params.iThumbnailSize = EContactListThumbnailSize;
+}
+}
 }
 //------------------------------------------------------------------------
 // CThumbnailServerSession::ModifyThumbnailSize
 // ---------------------------------------------------------------------------
 TThumbnailRequestParams& params = iRequestParams();
 TInt res = 0;
 // mime type
 if ( params.iMimeType.Des8() == KNullDesC8 && !Server()->SupportedMimeType(params.iMimeType) )
 {
 // try parsing from file extension
-res = Server()->MimeTypeFromFileExt( params.iFileName, params.iMimeType );
+if (params.iImport)
-if ( res == KErrNotFound )
+{
-{
+res = Server()->MimeTypeFromFileExt( params.iTargetUri, params.iMimeType );
-if( aFile )
+}
-{
+else
-// parsed type not in the list, resolve from file
+{
-params.iMimeType = Server()->ResolveMimeTypeL(*aFile);
+res = Server()->MimeTypeFromFileExt( params.iFileName, params.iMimeType );
 }
-else
-{
+if ( res == KErrNotFound )
-Server()->Fs().ShareProtected();
+{
-RFile64 file;
+if( aFile )
-CleanupClosePushL( file );
+{
+// parsed type not in the list, resolve from file
-User::LeaveIfError( file.Open( Server()->Fs(), params.iFileName, EFileShareReadersOrWriters ));
+params.iMimeType = Server()->ResolveMimeTypeL(*aFile);
-TN_DEBUG2( "CThumbnailServerSession::ResolveMimeType - file handle opened for %S", &params.iFileName );
+}
+else
-params.iMimeType = Server()->ResolveMimeTypeL(file);
+{
+Server()->Fs().ShareProtected();
-file.Close();
+RFile64 file;
-TN_DEBUG1("CThumbnailServerSession::ResolveMimeType - file handle closed");
+CleanupClosePushL( file );
-CleanupStack::Pop( &file );
+User::LeaveIfError( file.Open( Server()->Fs(), params.iFileName, EFileShareReadersOrWriters ));
-}
+TN_DEBUG2( "CThumbnailServerSession::ResolveMimeType - file handle opened for %S", &params.iFileName );
-}
-}
+params.iMimeType = Server()->ResolveMimeTypeL(file);
+file.Close();
+TN_DEBUG1("CThumbnailServerSession::ResolveMimeType - file handle closed");
+CleanupStack::Pop( &file );
+}
+}
+}
 }
 // ---------------------------------------------------------------------------
 // RThumbnailMessage::FilterSqlErr
 // ---------------------------------------------------------------------------
 //
 TInt CThumbnailServerSession::ConvertSqlErrToE32Err( TInt aReason )
 {
 TN_DEBUG2("CThumbnailServerSession::ConvertSqlErrToE32Err(%d)", aReason);
-TInt e32Err;
+TInt e32Err(aReason);
 if ( aReason >=  - 144 )
 // magic: [-1..-144] is E32 error range
 {
 // E32 error value or non-negative value
-e32Err = aReason;
+switch ( aReason )
+{
+case KErrServerTerminated:
+e32Err = KErrCorrupt;
+break;
+default:
+e32Err = aReason;
+}
 }
 else
 {
 switch ( aReason )
 {
 TN_DEBUG1( "CThumbnailServerSession::ClientThreadAlive() - message null");
 return EFalse;
 }
 }
 // End of file

branch	GCC_SURGE
changeset 32	a0ee3f735f8b
parent 30	b67379558a75
child 33	221be23823c5