diff -r 000000000000 -r 2014ca87e772 imagehandling_plat/thumbnailmanager_api/tsrc/src/ThumbnailManagerTestBlocks.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandling_plat/thumbnailmanager_api/tsrc/src/ThumbnailManagerTestBlocks.cpp Tue Jan 26 15:18:05 2010 +0200 @@ -0,0 +1,811 @@ +/* +* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Manager API tests +* +*/ + +// [INCLUDE FILES] - do not remove +#include +#include +#include + +#include +#include +#include +#include + +#include "ThumbnailManagerTest.h" + + +// ============================= LOCAL FUNCTIONS =============================== + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CThumbnailManagerTest::Delete +// Delete here all resources allocated and opened from test methods. +// Called from destructor. +// ----------------------------------------------------------------------------- +// +void CThumbnailManagerTest::Delete() + { + delete iPreviewThumbnail; + iPreviewThumbnail = NULL; + delete iThumbnail; + iThumbnail = NULL; + delete iEngine; + iEngine = NULL; + delete iObjectSource; + iObjectSource = NULL; + delete iCenrep; + iCenrep = NULL; + } + +// ----------------------------------------------------------------------------- +// CThumbnailManagerTest::RunMethodL +// Run specified method. Contains also table of test mothods and their names. +// ----------------------------------------------------------------------------- +// +TInt CThumbnailManagerTest::RunMethodL( CStifItemParser& aItem ) + { + static TStifFunctionInfo const KFunctions[] = + { + ENTRY( "CreateInstanceL", CThumbnailManagerTest::CreateInstanceL ), + ENTRY( "DeleteInstance", CThumbnailManagerTest::DeleteInstance ), + ENTRY( "SetThumbnailSizeL", CThumbnailManagerTest::SetThumbnailSizeL ), + ENTRY( "CheckThumbnailSizeL", CThumbnailManagerTest::CheckThumbnailSizeL ), + ENTRY( "SetThumbnailEnumSizeL", CThumbnailManagerTest::SetThumbnailEnumSizeL ), + ENTRY( "CreateSourceInstancePathL", CThumbnailManagerTest::CreateSourceInstancePathL ), + ENTRY( "CreateSourceInstanceHandleL", CThumbnailManagerTest::CreateSourceInstanceHandleL ), + ENTRY( "CreateSourceInstanceBufferL", CThumbnailManagerTest::CreateSourceInstanceBufferL ), + ENTRY( "CreateSourceInstanceBitmapL", CThumbnailManagerTest::CreateSourceInstanceBitmapL ), + ENTRY( "DeleteSourceInstance", CThumbnailManagerTest::DeleteSourceInstance ), + ENTRY( "GetThumbnailL", CThumbnailManagerTest::GetThumbnailL ), + ENTRY( "GetThumbnailByIdL", CThumbnailManagerTest::GetThumbnailByIdL ), + ENTRY( "SetThumbnailL", CThumbnailManagerTest::SetThumbnailL ), + ENTRY( "ImportThumbnailL", CThumbnailManagerTest::ImportThumbnailL ), + ENTRY( "CheckPreviewThumbnailL", CThumbnailManagerTest::CheckPreviewThumbnailL ), + ENTRY( "CheckThumbnailL", CThumbnailManagerTest::CheckThumbnailL ), + ENTRY( "CheckThumbnailCenrepL", CThumbnailManagerTest::CheckThumbnailCenrepL ), + ENTRY( "CancelPrevious", CThumbnailManagerTest::CancelPrevious ), + ENTRY( "ChangePreviousPriority", CThumbnailManagerTest::ChangePreviousPriority ), + ENTRY( "SetFlagsL", CThumbnailManagerTest::SetFlagsL ), + ENTRY( "CheckFlags", CThumbnailManagerTest::CheckFlags ), + ENTRY( "SetQualityPreferenceL", CThumbnailManagerTest::SetQualityPreferenceL ), + ENTRY( "CheckQualityPreference", CThumbnailManagerTest::CheckQualityPreference ), + ENTRY( "SetDisplayModeL", CThumbnailManagerTest::SetDisplayModeL ), + ENTRY( "CheckDisplayModeL", CThumbnailManagerTest::CheckDisplayModeL ), + ENTRY( "DeleteThumbnails", CThumbnailManagerTest::DeleteThumbnails ), + ENTRY( "DeleteThumbnailsByIdL", CThumbnailManagerTest::DeleteThumbnailsByIdL ), + ENTRY( "CreateThumbnails", CThumbnailManagerTest::CreateThumbnails ), + ENTRY( "UpdatePathL", CThumbnailManagerTest::UpdatePathL ), + ENTRY( "GetSupportedMimeTypesL", CThumbnailManagerTest::GetSupportedMimeTypesL ) + }; + + const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo ); + + return RunInternalL( KFunctions, count, aItem ); + } + +TInt CThumbnailManagerTest::CreateInstanceL( CStifItemParser& /*aItem*/ ) + { + _LIT( KPanicTxt, "CreateInstanceL" ); + __ASSERT_ALWAYS( !iEngine, User::Panic( KPanicTxt, 0 )); + + iEngine = CThumbnailManager::NewL( *this ); + + iCenrep = CThumbnailCenRep::NewL(); + iPersistentSizes = iCenrep->GetPersistentSizes(); + + iCurrentThumbnailSize = EUnknownThumbnailSize; + iDoNotCreate = EFalse; + iCreateThumbnails = EFalse; + + return KErrNone; + } + +TInt CThumbnailManagerTest::DeleteInstance( CStifItemParser& /*aItem*/ ) + { + // Bitmaps must be deleted before CThumbnailManager, since + // CThumbnailManager will close the FBS session + delete iPreviewThumbnail; + iPreviewThumbnail = NULL; + delete iThumbnail; + iThumbnail = NULL; + delete iEngine; + iEngine = NULL; + delete iObjectSource; + iObjectSource = NULL; + delete iCenrep; + iCenrep = NULL; + + return KErrNone; + } + +TInt CThumbnailManagerTest::SetThumbnailSizeL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "SetThumbnailSizeL" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt width = 0; + TInt height = 0; + User::LeaveIfError( aItem.GetNextInt( width )); + User::LeaveIfError( aItem.GetNextInt( height )); + iEngine->SetThumbnailSizeL( TSize( width, height )); + return KErrNone; + } + +TInt CThumbnailManagerTest::CheckThumbnailSizeL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "CheckThumbnailSize" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt width = 0; + TInt height = 0; + User::LeaveIfError( aItem.GetNextInt( width )); + User::LeaveIfError( aItem.GetNextInt( height )); + TInt ret = KErrArgument; + TSize size = iEngine->ThumbnailSize(); + + if ( size == TSize( width, height )) + { + ret = KErrNone; + } + + return ret; + } + +TInt CThumbnailManagerTest::SetThumbnailEnumSizeL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "SetThumbnailEnumSizeL" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt enumSize = 0; + User::LeaveIfError( aItem.GetNextInt( enumSize )); + + iEngine->SetThumbnailSizeL( (TThumbnailSize)enumSize ); + iCurrentThumbnailSize = (TThumbnailSize)enumSize; + + return KErrNone; + } + +TInt CThumbnailManagerTest::SetFlagsL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "SetFlagsL" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt flags = 0; + User::LeaveIfError( aItem.GetNextInt( flags )); + + iEngine->SetFlagsL(( CThumbnailManager::TThumbnailFlags )flags ); + + if (flags == CThumbnailManager::EDoNotCreate) + { + iDoNotCreate = ETrue; + } + else + { + iDoNotCreate = EFalse; + } + + return KErrNone; + } + +TInt CThumbnailManagerTest::CheckFlags( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "CheckFlags" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt flags = 0; + aItem.GetNextInt( flags ); + + if ( iEngine->Flags() != flags ) + { + return KErrArgument; + } + + return KErrNone; + } + +TInt CThumbnailManagerTest::SetQualityPreferenceL( CStifItemParser& aItem + ) + { + _LIT( KPanicTxt, "SetQualityPreferenceL" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt qp = 0; + User::LeaveIfError( aItem.GetNextInt( qp )); + + iEngine->SetQualityPreferenceL( (CThumbnailManager::TThumbnailQualityPreference)qp ); + return KErrNone; + } + +TInt CThumbnailManagerTest::CheckQualityPreference( CStifItemParser& + aItem ) + { + _LIT( KPanicTxt, "CheckQualityPreference" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt qp = 0; + aItem.GetNextInt( qp ); + + if ( iEngine->QualityPreference() != qp ) + { + return KErrArgument; + } + + return KErrNone; + } + +TInt CThumbnailManagerTest::SetDisplayModeL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "SetDisplayModeL" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt displaymode = 0; + User::LeaveIfError( aItem.GetNextInt( displaymode )); + + iEngine->SetDisplayModeL( (TDisplayMode)displaymode ); + return KErrNone; + } + +TInt CThumbnailManagerTest::CheckDisplayModeL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "CheckDisplayModeL" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt displaymode = 0; + User::LeaveIfError( aItem.GetNextInt( displaymode )); + + if ( iEngine->DisplayMode() != displaymode ) + { + return KErrArgument; + } + + return KErrNone; + } + +TInt CThumbnailManagerTest::CreateSourceInstancePathL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "CreateSrcPath" ); + __ASSERT_ALWAYS( !iObjectSource, User::Panic( KPanicTxt, 0 )); + + TPtrC path; + User::LeaveIfError( aItem.GetNextString( path )); + + TInt id = 0; + aItem.GetNextInt( id ); + + TFileName filePath( iDataPath ); + filePath.Append( path ); + filePath.ZeroTerminate(); + + iLog->Log( _L( "CreateSourceInstancePathL - path = %S" ), &filePath ); + + delete iObjectSource; + iObjectSource = NULL; + + iObjectSource = CThumbnailObjectSource::NewL( filePath, id ); + return KErrNone; + } + +TInt CThumbnailManagerTest::CreateSourceInstanceHandleL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "CreateSrcHandle" ); + __ASSERT_ALWAYS( !iObjectSource, User::Panic( KPanicTxt, 0 )); + + TPtrC path; + User::LeaveIfError( aItem.GetNextString( path )); + + TFileName filePath( iDataPath ); + filePath.Append( path ); + filePath.ZeroTerminate(); + + User::LeaveIfError( iFile.Open( iFs, filePath, EFileShareReadersOrWriters )); + iLog->Log( _L( "CreateSourceInstanceHandleL - path = %S" ), &filePath ); + + delete iObjectSource; + iObjectSource = NULL; + iObjectSource = CThumbnailObjectSource::NewL( iFile ); + return KErrNone; + } + +TInt CThumbnailManagerTest::CreateSourceInstanceBufferL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "CreateSrcBuffer" ); + __ASSERT_ALWAYS( !iObjectSource, User::Panic( KPanicTxt, 0 )); + + TPtrC path; + User::LeaveIfError( aItem.GetNextString( path )); + + TPtrC mimeType; + User::LeaveIfError( aItem.GetNextString( mimeType )); + + TFileName filePath( iDataPath ); + filePath.Append( path ); + filePath.ZeroTerminate(); + + User::LeaveIfError( iFile.Open( iFs, filePath, EFileShareReadersOrWriters )); + iLog->Log( _L( "CreateSourceInstanceBufferL - path = %S" ), &filePath ); + + TInt64 size; + User::LeaveIfError( iFile.Size( size ) ); + iBuffer = HBufC8::NewL( size ); + TPtr8 ptr = iBuffer->Des(); + iFile.Read( ptr ); + iFile.Close(); + + delete iObjectSource; + iObjectSource = NULL; + iObjectSource = CThumbnailObjectSource::NewL( iBuffer, mimeType, filePath ); + + iBuffer = NULL; + return KErrNone; + } + +TInt CThumbnailManagerTest::CreateSourceInstanceBitmapL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "CreateSrcBuffer" ); + __ASSERT_ALWAYS( !iObjectSource, User::Panic( KPanicTxt, 0 )); + + TPtrC path; + User::LeaveIfError( aItem.GetNextString( path )); + + TFileName filePath( iDataPath ); + filePath.Append( path ); + filePath.ZeroTerminate(); + + TPtrC target; + User::LeaveIfError( aItem.GetNextString( target )); + + TFileName targetPath( iDataPath ); + targetPath.Append( target ); + targetPath.ZeroTerminate(); + + iLog->Log( _L( "CreateSourceInstanceBitmapL - bitmap = %S" ), &filePath ); + iLog->Log( _L( "CreateSourceInstanceBitmapL - target = %S" ), &targetPath ); + + iBitmap = new (ELeave) CFbsBitmap(); + User::LeaveIfError(iBitmap->Load(filePath, 0)); + + delete iObjectSource; + iObjectSource = NULL; + iObjectSource = CThumbnailObjectSource::NewL( iBitmap, targetPath ); + + return KErrNone; + } + +TInt CThumbnailManagerTest::DeleteSourceInstance( CStifItemParser& /*aItem*/ ) + { + delete iObjectSource; + iObjectSource = NULL; + return KErrNone; + } + +TInt CThumbnailManagerTest::GetThumbnailL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "GetThumbnailL" ); + __ASSERT_ALWAYS( iObjectSource, User::Panic( KPanicTxt, 0 )); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 1 )); + + TInt clientData = NULL; + TInt priority = 0; + + TInt err = aItem.GetNextInt( clientData ); + if ( !err ) + { + aItem.GetNextInt( priority ); + } + + iPreviousRequestId = iEngine->GetThumbnailL( *iObjectSource, ( TAny* ) + clientData, priority ); + iLog->Log( _L( "GetThumbnailL - request id %d" ), iPreviousRequestId ); + + if (!iDoNotCreate) + { + iCreateThumbnails = EFalse; + } + + return KErrNone; + } + +TInt CThumbnailManagerTest::GetThumbnailByIdL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "GetThumbnailByIdL" ); + __ASSERT_ALWAYS( iObjectSource, User::Panic( KPanicTxt, 0 )); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 1 )); + + TInt id = 0; + TInt clientData = NULL; + TInt priority = 0; + + User::LeaveIfError( aItem.GetNextInt( id )); + TInt err = aItem.GetNextInt( clientData ); + if ( !err ) + { + aItem.GetNextInt( priority ); + } + + iPreviousRequestId = iEngine->GetThumbnailL( id, (TAny*)clientData, priority ); + iLog->Log( _L( "GetThumbnailByIdL - request id %d" ), iPreviousRequestId ); + + if (!iDoNotCreate) + { + iCreateThumbnails = EFalse; + } + + return KErrNone; + } + +TInt CThumbnailManagerTest::SetThumbnailL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "SetThumbnailL" ); + __ASSERT_ALWAYS( iObjectSource, User::Panic( KPanicTxt, 0 )); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 1 )); + + TInt clientData = NULL; + TInt priority = 0; + + TInt err = aItem.GetNextInt( clientData ); + if ( !err ) + { + aItem.GetNextInt( priority ); + } + + iPreviousRequestId = iEngine->SetThumbnailL( *iObjectSource, ( TAny* ) + clientData, priority ); + iLog->Log( _L( "SetThumbnailL - request id %d" ), iPreviousRequestId ); + + if (!iDoNotCreate) + { + iCreateThumbnails = EFalse; + } + + return KErrNone; + } + +TInt CThumbnailManagerTest::ImportThumbnailL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "ImportThumbnailL" ); + __ASSERT_ALWAYS( iObjectSource, User::Panic( KPanicTxt, 0 )); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 1 )); + + TInt clientData = NULL; + TInt priority = 0; + TPtrC path; + + User::LeaveIfError( aItem.GetNextString( path )); + + TFileName filePath( iDataPath ); + filePath.Append( path ); + filePath.ZeroTerminate(); + + TInt err = aItem.GetNextInt( clientData ); + if ( !err ) + { + aItem.GetNextInt( priority ); + } + + iPreviousRequestId = iEngine->ImportThumbnailL( *iObjectSource, filePath, + (TAny*)clientData, priority ); + iLog->Log( _L( "ImportThumbnailL - request id %d" ), iPreviousRequestId ); + + if (!iDoNotCreate) + { + iCreateThumbnails = EFalse; + } + + return KErrNone; + } + +void CThumbnailManagerTest::ThumbnailPreviewReady( MThumbnailData& + aThumbnail, TThumbnailRequestId aId ) + { + iLog->Log( _L( "ThumbnailPreviewReady aId=%d" ), aId ); + delete iPreviewThumbnail; + iPreviewThumbnail = aThumbnail.DetachBitmap(); + iPreviewThumbnailCbId = aId; + Signal( KErrNone ); + } + +void CThumbnailManagerTest::ThumbnailReady( TInt aError, MThumbnailData& + aThumbnail, TThumbnailRequestId aId ) + { + iLog->Log( _L( "ThumbnailReady aError=%d aId=%d" ), aError, aId ); + delete iThumbnail; + iThumbnail = aThumbnail.DetachBitmap(); + iThumbnailCbId = aId; + + // ignore KErrNotFound, if auto create disabled (CreateThumbnails used) + if (aError == KErrNotFound && iCreateThumbnails) + { + for ( TInt i = 0 ; i < iPersistentSizes.Count(); i++ ) + { + if ( iPersistentSizes[i].iType == iCurrentThumbnailSize && + !iPersistentSizes[i].iAutoCreate ) + { + aError = KErrNone; + break; + } + } + } + + Signal( aError ); + } + +TInt CThumbnailManagerTest::CheckPreviewThumbnailL( CStifItemParser& aItem ) + { + if ( iPreviewThumbnail ) + { + TInt width = 0; + TInt height = 0; + TInt displaymode = 0; + User::LeaveIfError( aItem.GetNextInt( width )); + User::LeaveIfError( aItem.GetNextInt( height )); + User::LeaveIfError( aItem.GetNextInt( displaymode )); + TSize size = iPreviewThumbnail->SizeInPixels(); + iLog->Log( _L( + "CheckPreviewThumbnailL - bitmap size %dx%d (expecting %dx%d)" ), + size.iWidth, size.iHeight, width, height ); + iLog->Log( _L( "CheckPreviewThumbnailL - bitmap mode %d (expecting %d)" + ), iPreviewThumbnail->DisplayMode(), displaymode ); + if ( size != TSize( width, height )) + { + iLog->Log( _L( "CheckPreviewThumbnailL - size mismatch" )); + User::Leave( KErrArgument ); + } + else if ( displaymode != iPreviewThumbnail->DisplayMode()) + { + iLog->Log( _L( "CheckPreviewThumbnailL - displaymode mismatch" )); + User::Leave( KErrArgument ); + } + else + { + iLog->Log( _L( "CheckPreviewThumbnailL - ok" )); + } + } + else + { + // Bitmap missing + iLog->Log( _L( "CheckPreviewThumbnailL - preview bitmap NULL" )); + User::Leave( KErrUnknown ); + } + return KErrNone; + } + +TInt CThumbnailManagerTest::CheckThumbnailL( CStifItemParser& aItem ) + { + if ( iThumbnail ) + { + TInt width = 0; + TInt height = 0; + TInt displaymode = 0; + User::LeaveIfError( aItem.GetNextInt( width )); + User::LeaveIfError( aItem.GetNextInt( height )); + User::LeaveIfError( aItem.GetNextInt( displaymode )); + TSize size = iThumbnail->SizeInPixels(); + iLog->Log( _L( "CheckThumbnailL - bitmap size %dx%d (expecting %dx%d)" ) + , size.iWidth, size.iHeight, width, height ); + iLog->Log( _L( "CheckThumbnailL - bitmap mode %d (expecting %d)" ), + iThumbnail->DisplayMode(), displaymode ); + + // one needs to match, aspect ratio scaling makes this difficult... + if ( size.iWidth != width && size.iHeight != height ) + { + iLog->Log( _L( "CheckThumbnailL - size mismatch" )); + User::Leave( KErrArgument ); + } + else if ( displaymode != iThumbnail->DisplayMode()) + { + iLog->Log( _L( "CheckThumbnailL - displaymode mismatch" )); + } + else + { + iLog->Log( _L( "CheckThumbnailL - ok" )); + } + } + else + { + // Bitmap missing + iLog->Log( _L( "CheckThumbnailL - bitmap NULL" )); + User::Leave( KErrNotFound ); + } + return KErrNone; + } + +TInt CThumbnailManagerTest::CheckThumbnailCenrepL( CStifItemParser& aItem ) + { + TInt err = KErrNone; + TBool full = EFalse; + + TInt sizeType; + TInt displaymode = 0; + User::LeaveIfError( aItem.GetNextInt( sizeType )); + User::LeaveIfError( aItem.GetNextInt( displaymode )); + + TThumbnailSize size = (TThumbnailSize)sizeType; + if (size == EImageFullScreenThumbnailSize || + size == EVideoFullScreenThumbnailSize || + size == EAudioFullScreenThumbnailSize) + { + full = ETrue; + } + + if ( iThumbnail ) + { + TInt width = 0; + TInt height = 0; + + for ( TInt i = 0 ; i < iPersistentSizes.Count(); i++ ) + { + if ( iPersistentSizes[i].iType == size ) + { + width = iPersistentSizes[i].iSize.iWidth; + height = iPersistentSizes[i].iSize.iHeight; + break; + } + } + + TSize thumbSize = iThumbnail->SizeInPixels(); + + iLog->Log( _L( "CheckThumbnailCenrepL - bitmap size %dx%d (expecting %dx%d)" ) + , thumbSize.iWidth, thumbSize.iHeight, width, height ); + iLog->Log( _L( "CheckThumbnailCenrepL - bitmap mode %d (expecting %d)" ), + iThumbnail->DisplayMode(), displaymode ); + + // one needs to match, and both need to be smaller than cenrep value + if ( (thumbSize.iWidth == width || thumbSize.iHeight == height) && + thumbSize.iWidth <= width && thumbSize.iHeight <= height) + { + iLog->Log( _L( "CheckThumbnailCenrepL - ok" )); + } + else if (full && (thumbSize.iWidth <= width && thumbSize.iHeight <= height)) + { + iLog->Log( _L( "CheckThumbnailCenrepL - fullscreen ok, not upscaled" )); + } + else + { + iLog->Log( _L( "CheckThumbnailCenrepL - size mismatch" )); + err = KErrArgument; + } + + // check display mode + if ( displaymode != iThumbnail->DisplayMode()) + { + iLog->Log( _L( "CheckThumbnailCenrepL - displaymode mismatch" )); + err = KErrArgument; + } + } + else + { + for ( TInt i = 0 ; i < iPersistentSizes.Count(); i++ ) + { + if ( iPersistentSizes[i].iType == size && iPersistentSizes[i].iAutoCreate) + { + // Bitmap missing + iLog->Log( _L( "CheckThumbnailCenrepL - bitmap NULL" )); + err = KErrNotFound; + break; + } + } + } + + return err; + } + +TInt CThumbnailManagerTest::CancelPrevious( CStifItemParser& /*aItem*/ ) + { + _LIT( KPanicTxt, "CancelPrevious" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt err = iEngine->CancelRequest( iPreviousRequestId ); + iLog->Log( _L( "CancelPrevious() returned %d" ), err ); + return err; + } + +TInt CThumbnailManagerTest::ChangePreviousPriority( CStifItemParser& + aItem ) + { + _LIT( KPanicTxt, "ChangePreviousPriority" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt priority = 0; + aItem.GetNextInt( priority ); + + TInt err = iEngine->ChangePriority( iPreviousRequestId, priority ); + iLog->Log( _L( "ChangePriority() returned %d" ), err ); + return err; + } + + +TInt CThumbnailManagerTest::DeleteThumbnails( CStifItemParser& /*aItem*/ ) + { + iEngine->DeleteThumbnails( *iObjectSource ); + return KErrNone; + } + +TInt CThumbnailManagerTest::DeleteThumbnailsByIdL( CStifItemParser& aItem ) + { + TInt id = 0; + User::LeaveIfError( aItem.GetNextInt( id )); + + iEngine->DeleteThumbnails( id ); + return KErrNone; + } + + +TInt CThumbnailManagerTest::CreateThumbnails( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "CreateThumbnails" ); + __ASSERT_ALWAYS( iObjectSource, User::Panic( KPanicTxt, 0 )); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 1 )); + + TInt priority = 0; + + aItem.GetNextInt( priority ); + + TInt id; + id = iEngine->CreateThumbnails( *iObjectSource, priority ); + if (id < 0) + { + iLog->Log( _L( "CreateThumbnails - error %d" ), id ); + return id; + } + else + { + iPreviousRequestId = id; + iLog->Log( _L( "CreateThumbnails - request id %d" ), iPreviousRequestId ); + } + + iCreateThumbnails = ETrue; + + return KErrNone; + } + +TInt CThumbnailManagerTest::UpdatePathL( CStifItemParser& aItem ) + { + _LIT( KPanicTxt, "UpdatePath" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + TInt id = 0; + TPtrC path; + User::LeaveIfError( aItem.GetNextInt( id )); + User::LeaveIfError( aItem.GetNextString( path )); + + TFileName filePath( iDataPath ); + filePath.Append( path ); + filePath.ZeroTerminate(); + + iLog->Log( _L( "UpdatePath - path = %S" ), &filePath ); + + iEngine->UpdateThumbnailsL(id, filePath, 0, 1000, CActive::EPriorityIdle); + + return KErrNone; + } + +TInt CThumbnailManagerTest::GetSupportedMimeTypesL( CStifItemParser& /*aItem*/ ) + { + _LIT( KPanicTxt, "GetSupportedMimeTypesL" ); + __ASSERT_ALWAYS( iEngine, User::Panic( KPanicTxt, 0 )); + + iEngine->GetSupportedMimeTypesL(); + + return KErrNone; + } + + +// ========================== OTHER EXPORTED FUNCTIONS ========================= +// None + +// [End of File] - Do not remove