/*

* Copyright (c) 2008 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:  Video Playback User Input Handler Test class for STIF unit testing

*

*/

// Version : %version: 1 %

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <e32std.h>

#include <w32std.h>

#include <coeaui.h>

#include <aknutils.h>

#include <aknviewappui.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "ut_collectionplugintest.h"

#include "mpxlog.h"

#include <vcxmyvideosuids.h>

#include <vcxmyvideosdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionplugin.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionmessagedefs.h>

#include <vcxmyvideosdefs.h>

#include "vcxmyvideosactivetask.h"

#include "vcxmyvideosmdsdb.h"

#include "vcxmyvideosvideocache_stub.h"

#define private public

#include "vcxmyvideoscollectionplugin.h"

#undef private

_LIT( KTestModuleName, "CollectionPluginTest" );

_LIT( KLogLocation, "In %S" );

const TInt KInvalidId( -100 );

const TInt KSelectAll( -2 );

enum EMPXMediaAttribute

    {

    ETestMediaGeneralId = 1,

    ETestMediaTitle

    };

enum EStubs

    {

    EActiveTask = 1,

    EAlbums,

    EAsyncFileOperations,

    ECategories,

    EMDSDB,

    EMessageList,

    EOpenHandler,

    EVideoCache

    };

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CCollectionPluginTest::Delete

// Delete here all resources allocated and opened from test methods.

// Called from destructor.

// -----------------------------------------------------------------------------

//

void CCollectionPluginTest::Delete()

{

    if( iCollection )

        {

        delete iCollection;

        iCollection = NULL;

        }

    if( iPath )

        {

        delete iPath;

        iPath = NULL;

        }

    if( iMessageList )

        {

        iMessageList->Reset();

        delete iMessageList;

        iMessageList = NULL;

        }

    if( iMedia )

        {

        delete iMedia;

        iMedia = NULL;

        }

    if( iCommand )

        {

        delete iCommand;

        iCommand = NULL;

        }

    iAttrs.Close();

}

// -----------------------------------------------------------------------------

//   CCollectionPluginTest::CreateL

// -----------------------------------------------------------------------------

//

void CCollectionPluginTest::CreateL()

{

    TInt arguments( 0 );

    iCollection = CVcxMyVideosCollectionPlugin::NewL( &arguments );

    iCollection->SetObserver( *this );

    iMessageList = CMPXMediaArray::NewL();

    iPath = CMPXCollectionPath::NewL();

}

// -----------------------------------------------------------------------------

// CCollectionPluginTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::RunMethodL( CStifItemParser& aItem )

{

    static TStifFunctionInfo const KFunctions[] =

    {

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

        ENTRY( "CreateNewMedia", CCollectionPluginTest::CreateNewMediaL ),

        ENTRY( "SetMediaAttribute", CCollectionPluginTest::SetMediaAttributeL ),

        ENTRY( "AddMediaToCache", CCollectionPluginTest::AddMediaToCacheL ),

        ENTRY( "RemoveMediaFromCache", CCollectionPluginTest::RemoveMediaFromCacheL ),

        ENTRY( "CheckMediaCount", CCollectionPluginTest::CheckMediaCountL ),

        ENTRY( "OpenL", CCollectionPluginTest::OpenL ),

        ENTRY( "SelectPath", CCollectionPluginTest::SelectPathL ),

        ENTRY( "SelectPathId", CCollectionPluginTest::SelectPathIdL ),

        ENTRY( "InsertToPath", CCollectionPluginTest::InsertToPathL ),

        ENTRY( "SelectAttributes", CCollectionPluginTest::SelectAttributesL ),

        ENTRY( "MediaL", CCollectionPluginTest::MediaL ),

        ENTRY( "CancelRequest", CCollectionPluginTest::CancelRequest ),

        ENTRY( "CommandL", CCollectionPluginTest::CommandL ),

        ENTRY( "FindAllL", CCollectionPluginTest::FindAllL ),

        ENTRY( "FindAllSyncL", CCollectionPluginTest::FindAllSyncL ),

        ENTRY( "GetCapabilities", CCollectionPluginTest::GetCapabilities ),

        ENTRY( "AddL", CCollectionPluginTest::AddL ),

        ENTRY( "RemoveL", CCollectionPluginTest::RemoveL ),

        ENTRY( "SetL", CCollectionPluginTest::SetL ),

        ENTRY( "HandleStepL", CCollectionPluginTest::HandleStepL ),

        ENTRY( "CreateNewCmd", CCollectionPluginTest::CreateNewCmdL ),

        ENTRY( "CheckCurrentCmd", CCollectionPluginTest::CheckCurrentCmdL ),

        ENTRY( "SetNewCmd", CCollectionPluginTest::SetNewCmdL ),

        ENTRY( "SetVideoListFetching", CCollectionPluginTest::SetVideoListFetchingL ),

        ENTRY( "CancelCacheListFetching", CCollectionPluginTest::CancelCacheListFetchingL ),

        ENTRY( "HandleMyVideosDbEvent", CCollectionPluginTest::HandleMyVideosDbEvent ),

        ENTRY( "HandleCreateVideoListResp", CCollectionPluginTest::HandleCreateVideoListResp ),

        ENTRY( "HandleObjectPresentNotification", CCollectionPluginTest::HandleObjectPresentNotificationL ),

        ENTRY( "AddVideoToMdsAndCacheL", CCollectionPluginTest::AddVideoToMdsAndCacheL ),

        ENTRY( "SetVideoL", CCollectionPluginTest::SetVideoL ),

        ENTRY( "SendMyVideosMessageL", CCollectionPluginTest::SendMyVideosMessageL ),

        ENTRY( "SendMessages", CCollectionPluginTest::SendMessages ),

        ENTRY( "CategoriesL", CCollectionPluginTest::CategoriesL ),

        ENTRY( "NotifyNewVideosCountDecreasedL", CCollectionPluginTest::NotifyNewVideosCountDecreasedL ),

        ENTRY( "DeleteStub", CCollectionPluginTest::DeleteStubL ),

        ENTRY( "AlbumsL", CCollectionPluginTest::AlbumsL ),

    };

    const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

}

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void CCollectionPluginTest::LogMethod( TPtrC aMethod )

    {

    // Print to UI

    TBuf< 64 > buffer;

    buffer.Format( KLogLocation, &aMethod );

    TestModuleIf().Printf( 0, KTestModuleName, buffer );

    // Print to log file

    iLog->Log( buffer );

    }

// -----------------------------------------------------------------------------

//  CCollectionPluginTest::SetMessageResponse

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::DeleteStubL( CStifItemParser& aItem )

    {

    TInt error( KErrNone );

    TInt stub( KErrNotFound );

    aItem.GetNextInt( stub );

    switch( stub )

        {

        case EActiveTask:

            TRAP( error, delete iCollection->iActiveTask );

            break;

        case EAlbums:

            TRAP( error, delete iCollection->iAlbums );

            break;

        case EAsyncFileOperations:

            TRAP( error, delete iCollection->iAsyncFileOperations );

            break;

        case ECategories:

            TRAP( error, delete iCollection->iCategories );

            break;

        case EMDSDB:

            TRAP( error, delete iCollection->iMyVideosMdsDb );

            break;

        case EMessageList:

            TRAP( error, delete iCollection->iMessageList );

            break;

        case EOpenHandler:

            TRAP( error, delete iCollection->iOpenHandler );

            break;

        case EVideoCache:

            TRAP( error, delete iCollection->iCache );

            break;

        default:

            break;

        }

    return error;

    }

// -----------------------------------------------------------------------------

//  CCollectionPluginTest::CheckMessageResponse

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::CheckCurrentCmdL( CStifItemParser& aItem )

    {

    TInt error( KErrNone );

    aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

    // CMD ID

    TUint32 cmdId( 0 );

    TPtrC cmdIdStr;

    if( aItem.GetNextString( cmdIdStr ) == KErrNone )

        {

        TLex lex( cmdIdStr );

        lex.Val( cmdId, EHex );

        }

    // MV CMD ID

    TInt cmdMV( KErrNotFound );

    if( cmdId == KVcxCommandIdMyVideos )

        {

        aItem.GetNextInt( cmdMV );

        }

    if( iCollection->iActiveTask->iCurCommand == NULL && !cmdId )

        {

        return KErrNone;

        }

    TMPXCommandId commandId = iCollection->iActiveTask->iCurCommand->ValueTObjectL<TMPXCommandId>( KMPXCommandGeneralId );

    if( commandId != cmdId )

        {

        error = KErrCorrupt;

        }

    if( commandId == KVcxCommandIdMyVideos )

        {

        TInt currCmdMV = iCollection->iActiveTask->iCurCommand->ValueTObjectL<TUint32>( KVcxMediaMyVideosCommandId );

        if( currCmdMV != cmdMV )

            {

            error = KErrCorrupt;

            }

        }

    return error;

    }

// -----------------------------------------------------------------------------

//  CCollectionPluginTest::CreateNewMediaL

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::CreateNewMediaL( CStifItemParser& /*aItem*/ )

    {    

    delete iMedia;

    iMedia = NULL;

    iMedia = CMPXMedia::NewL(); // NULL;

    return KErrNone;

    }

// -----------------------------------------------------------------------------

//  CCollectionPluginTest::CreateNewMediaL

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::SetMediaAttributeL( CStifItemParser& aItem )

    {

    CleanupStack::PushL( iMedia );

    aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

    TInt attribute( KErrNotFound );

    aItem.GetNextInt( attribute );

    switch( attribute )

        {

        case ETestMediaGeneralId:

            {

            TInt mediaId( 0 );

            aItem.GetNextInt( mediaId );

            TInt mediaType( KVcxMvcMediaTypeVideo );

            aItem.GetNextInt( mediaType );

            TMPXItemId mpxId( mediaId, mediaType );

            iMedia->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, mpxId );

            }

            break;

        case ETestMediaTitle:

            {

            TPtrC value;

            aItem.GetNextString( value );

            iMedia->SetTextValueL( KMPXMediaGeneralTitle, value );                

            }

            break;

        default:

            break;

        }

    CleanupStack::Pop( iMedia );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

//  CCollectionPluginTest::CreateNewCmdL

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::CreateNewCmdL( CStifItemParser& aItem )

    {

    TInt error( KErrNone );

    aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

    // COMMAND SYNC

    TInt paramSync( 0 );

    aItem.GetNextInt( paramSync );

    // CMD ID

    TUint32 cmdId( 0 );

    TPtrC cmdIdStr;

    if( aItem.GetNextString( cmdIdStr ) == KErrNone )

        {

        TLex lex( cmdIdStr );

        User::LeaveIfError( lex.Val( cmdId, EHex ) );

        }

    // MV CMD ID

    TInt cmdMV( KErrNotFound );

    if( cmdId == KVcxCommandIdMyVideos )

        {

        aItem.GetNextInt( cmdMV );

        }

    delete iCommand;

    iCommand = NULL;

    iCommand = CreateMpxCommandLC( cmdId, cmdMV, paramSync );

    switch( cmdId )

        {

        case KMPXCommandIdCollectionAdd: // SYNC

            {

            iCommand->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, iMedia );

            }

            break;

        case KMPXCommandIdCollectionSet: // SYNC

            {

            iCommand->SetCObjectValueL<CMPXMedia>( KMPXCommandColSetMedia, iMedia );

            }

            break;

        case KMPXCommandIdCollectionRemoveMedia:

            {

            TMPXItemId itemId = iMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

            iCommand->SetTObjectValueL( KMPXMediaGeneralId, itemId );

            }

            break;

        default:

            break;

        }

    switch( cmdMV )

        {

        case KVcxCommandMyVideosGetMediaFullDetailsByMpxId:

            {

            TMPXItemId itemId = iMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

            iCommand->SetTObjectValueL( KMPXMediaGeneralId, itemId );

            }

            break;

        case KVcxCommandMyVideosGetMediasByMpxId:

            {

            CMPXMediaArray* mediaArray = CMPXMediaArray::NewL();

            CleanupStack::PushL( mediaArray );

            TInt id( 0 );

            while( aItem.GetNextInt( id ) == KErrNone )

                {

                CMPXMedia* item = CMPXMedia::NewL();

                CleanupStack::PushL( item ); 

                TMPXItemId itemId;

                itemId.iId1 = id;

                itemId.iId2 = KVcxMvcMediaTypeVideo;

                item->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, itemId );

                mediaArray->AppendL( *item );

                CleanupStack::PopAndDestroy( item );

                }

            if( id != KErrNotFound )

                {

                iCommand->SetCObjectValueL<CMPXMediaArray>( KMPXMediaArrayContents, mediaArray );

                }

            CleanupStack::Pop( mediaArray );

            }

            break;

        case KVcxCommandMyVideosMove:

        case KVcxCommandMyVideosCopy:

        case KVcxCommandMyVideosDelete:

        case KVcxCommandMyVideosCancelMoveOrCopy: // SYNC

        case KVcxCommandMyVideosCancelDelete: // SYNC

        case KVcxCommandMyVideosAddAlbum: // SYNC

        case KVcxCommandMyVideosAddToAlbum: // ASYNC

        case KVcxCommandMyVideosRemoveFromAlbum: // ASYNC

            {

            if( iMedia )

                {

                iCommand->SetCObjectValueL<CMPXMedia>( KMPXCommandColSetMedia, iMedia );

                }

            }

            break;

        default:

            break;

        }

    CleanupStack::Pop( iCommand );

    return error;

    }

// -----------------------------------------------------------------------------

//   CCollectionPluginTest::

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::SetNewCmdL( CStifItemParser& /*aItem*/ )

    {

    LogMethod(_L("SetNewCmdL"));

    TRAPD( error, iCollection->iActiveTask->SetNewCommandL( *iCommand ) );

    return error;

    }

// -----------------------------------------------------------------------------

//   CCollectionPluginTest::SetListCacheFetching

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::CancelCacheListFetchingL( CStifItemParser& aItem )

    {

    LogMethod(_L("CancelCacheListFetchingL"));

    TInt value( KErrNotFound );

    aItem.GetNextInt( value );

    TBool enabled( value );

    TRAPD( error, iCollection->iCache->iCancelListFetching = enabled );

    return error;

    }

// -----------------------------------------------------------------------------

//  CCollectionPluginTest::AddMediaToCacheL

// -----------------------------------------------------------------------------

//

TInt CCollectionPluginTest::AddMediaToCacheL( CStifItemParser& /*aItem*/ )

    {

    CMPXMediaArray* cache = iCollection->iCache->iVideoList->Value<CMPXMediaArray>( KMPXMediaArrayContents );

    TRAPD( error, cache->AppendL( *iMedia ) );

    iCollection->iCache->iVideoList->SetCObjectValueL<CMPXMediaArray>( KMPXMediaArrayContents, cache);

    return error;

    }

// -----------------------------------------------------------------------------

//   CCollectionPluginTest::

// -----------------------------------------------------------------------------

//

/*

TInt CCollectionPluginTest::AddMediaToCacheL( CStifItemParser& aItem )

    {

    LogMethod(_L("AddMediaToCache"));

    TInt err( 0 );

    CMPXMedia* media = CMPXMedia::NewL();

    TInt mediaId( 0 );

    aItem.GetNextInt( mediaId );

    TMPXItemId mpxId( mediaId, 0 );

    media->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, mpxId );

    CMPXMediaArray* medias = iCollection->iCache->iVideoList->Value<CMPXMediaArray>( KMPXMediaArrayContents );

    medias->AppendL(*media);

    delete media;

    return err;

    }*/

// -----------------------------------------------------------------------------

//   CCollectionPluginTest::