/*

* 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;