--- /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 <e32svr.h>
+#include <StifParser.h>
+#include <Stiftestinterface.h>
+
+#include <fbs.h>
+#include <sqldb.h>
+#include <ImageConversion.h>
+#include <thumbnailmanager.h>
+
+#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