/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

*/

// INCLUDE FILES

#include <e32svr.h>

#include <e32std.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <mmf/common/mmfcontrollerpluginresolver.h> // CleanupResetAndDestroyPushL

#include <e32cons.h>

#include <mpxcollectionutility.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediageneralextdefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcollectionpath.h>

#include <mpxmessage2.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxmediabase.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include "VCXMyVideosTestUtils.h"

#include "VCXTestLog.h"

#include "CVcxTestActiveWait.h"

#include "VCXMyVideosCollectionPluginTester.h"

#include "VCXMyVideosTestUtils.h"

#include "VCXMyVideosTestCommon.h"

#include "vcxmyvideoscollection.hrh"

#include "vcxmyvideosmdsdb.h"

#include "vcxmyvideosdefs.h"

// CONSTANTS

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

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

// CVCXMyVideosCollectionPluginTester::NewL

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

//

CVCXMyVideosCollectionPluginTester* CVCXMyVideosCollectionPluginTester::NewL(

            MVCXMyVideosCollectionPluginTesterObserver* aObserver, CVCXMyVideosTestUtils* aTestUtils )

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::NewL");

    CVCXMyVideosCollectionPluginTester* self = 

        new (ELeave) CVCXMyVideosCollectionPluginTester( aObserver, aTestUtils );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::NewL");

    return self;

    }

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

// CVCXMyVideosCollectionPluginTester::CVCXMyVideosCollectionPluginTester

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

//

CVCXMyVideosCollectionPluginTester::CVCXMyVideosCollectionPluginTester( 

        MVCXMyVideosCollectionPluginTesterObserver* aObserver,

        CVCXMyVideosTestUtils* aTestUtils ) :

iObserver( aObserver ), 

iTestUtils( aTestUtils ),

iCurrentLevelName( NULL ),

iAutomaticContentRefresh( ETrue),

iCurrentOpenedLevelIndex( -1 )

    {

    }

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

// CVCXMyVideosCollectionPluginTester::~CVCXMyVideosCollectionPluginTester

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

//

CVCXMyVideosCollectionPluginTester::~CVCXMyVideosCollectionPluginTester( )

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::~CVCXMyVideosCollectionPluginTester");

    if( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    iCollectionUtility = NULL;

    delete iCollectionEntries;

    iCollectionEntries = NULL;

    if( iOldMediaArray )

        {

        iOldMediaArray->Reset();

        delete iOldMediaArray;

        iOldMediaArray = NULL;

        }

    if( iMediaArray )

        {

        PrintMediasL( iMediaArray, EFalse, _L("Items") );

        iMediaArray->Reset();

        delete iMediaArray;

        iMediaArray = NULL;

        }

    if( iMediaArrayCopy )

        {

        iMediaArrayCopy->Reset();

        delete iMediaArrayCopy;

        iMediaArrayCopy = NULL;

        }

    iFs.Close();

    if( iActiveWait )

        {

        iActiveWait->Stop();

        delete iActiveWait;

        iActiveWait = NULL;

        }

    iRequestedMediaIds.Close();

    if( iFullMedia )

        {

        delete iFullMedia;

        iFullMedia = NULL;

        }

    iInsertedItemIds.Close();

    iDeletedItemIds.Close();

    delete iCurrentLevelName;

    iCurrentLevelName = NULL;

    iTransactions->CheckTransactions();

    delete iTransactions;

    iTransactions = NULL;

    iAlbumNames.ResetAndDestroy();

    iAlbumNames.Close();

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::~CVCXMyVideosCollectionPluginTester");

    }

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

// CVCXMyVideosCollectionPluginTester::ConstructL

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

//

void CVCXMyVideosCollectionPluginTester::ConstructL()

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::ConstructL");

    iActiveWait = CVcxTestActiveWait::NewL();

    User::LeaveIfError( iFs.Connect() );

    iTransactions = CVCXMyVideosTestTransactions::NewL();

    iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeIsolated );

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::ConstructL");

    }

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

// CVCXMyVideosCollectionPluginTester::ConstructL

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

//

void CVCXMyVideosCollectionPluginTester::OpenCollectionL( TUint32 aCollectionUid )

    {

    VCXLOGLO2(">>>CVCXMyVideosCollectionPluginTester::OpenCollectionL (%d)", this);

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL( path );

    iCollectionUid = TUid::Uid( aCollectionUid );

    path->AppendL( aCollectionUid );

    SetRefreshStatus( ETrue );

    VCXLOGLO2("CVCXMyVideosCollectionPluginTester::OpenCollectionL: collectionId: 0x%x", aCollectionUid);

    iCollectionUtility->Collection().OpenL( *path );

    iCurrentOpenedLevelIndex = -1;

    CleanupStack::PopAndDestroy( path );

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::OpenCollectionL");

    }

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

// CVCXMyVideosCollectionPluginTester::OpenLevelL

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

//

void CVCXMyVideosCollectionPluginTester::OpenLevelL( const TDesC& aLevelName )

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::OpenLevelL (by name)");

    if( GetCurrentLevel() != 2 )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Error. My videos collection must be open!");

        User::Leave( KErrGeneral );

        }

    CMPXMedia* media;

    int levelIndex(-1);

    // From last to first

    for( TInt i = iMediaArray->Count()-1; i >= 0; i-- )

        {

        media = (*iMediaArray)[i];

        if( media->IsSupported( KMPXMediaGeneralTitle ) )

            {

            if( media->ValueText( KMPXMediaGeneralTitle ).Compare( aLevelName ) == KErrNone )

                {

                TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));

                VCXLOGLO3("CVCXMyVideosCollectionPluginTester::OpenLevelL: mpx id1: %d, id2: %d", itemId.iId1, itemId.iId2);

                levelIndex = i;

                delete iCurrentLevelName;

                iCurrentLevelName = NULL;

                iCurrentLevelName = media->ValueText( KMPXMediaGeneralTitle ).AllocL();

                break;

                }

            }

        }

    if( levelIndex == -1 )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:::OpenLevelL: Couldn't find the level!");

        User::Leave( KErrNotFound );

        }

    // Open the level

    iCollectionUtility->Collection().OpenL( levelIndex );

    iCurrentOpenedLevelIndex = levelIndex;

    SetRefreshStatus( ETrue );

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester:::OpenLevelL (by name)");

    }

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

// CVCXMyVideosCollectionPluginTester::OpenLevelL

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

//

void CVCXMyVideosCollectionPluginTester::OpenLevelL( TInt aIndex )

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::OpenLevelL");

    if( GetCurrentLevel() != 2 )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Error. My videos collection must be open!");

        User::Leave( KErrGeneral );

        }

    if( aIndex >= 0 || aIndex < iMediaArray->Count() )

        {

        CMPXMedia* media(NULL);

        media = (*iMediaArray)[aIndex];

        if( media->IsSupported( KMPXMediaGeneralTitle ) )

            {

            delete iCurrentLevelName;

            iCurrentLevelName = NULL;

            iCurrentLevelName = media->ValueText( KMPXMediaGeneralTitle ).AllocL();

            }

        }

    else

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester::OpenLevelL: level index is invalid. Opening..");

        }

    // Open the level

    iCollectionUtility->Collection().OpenL( aIndex );

    iCurrentOpenedLevelIndex = aIndex;

    SetRefreshStatus( ETrue );

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::OpenLevelL");

    }

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

// CVCXMyVideosCollectionPluginTester::RefreshContentsL

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

//

void CVCXMyVideosCollectionPluginTester::RefreshContentsL()

    {

    //VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::RefreshContentsL");

#if 0

    // No need to refresh if My Videos category is not open.

    if( GetCurrentLevel() != 3)

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: No refresh because level.");

        return;

        }

#endif 

    // Wait previous refresh to complete.

    if( IsRefreshing() )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Refresh already active.");

        return;

        }

    VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: ----------------------------");

    VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Refreshing video list ----->");

    VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: ----------------------------");

    iCollectionUtility->Collection().OpenL();

    SetRefreshStatus( ETrue );

    //VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::RefreshContentsL");

    }

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

// CVCXMyVideosCollectionPluginTester::GetMediasByMpxIdL

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

//

void CVCXMyVideosCollectionPluginTester::GetMediasByMpxIdL( TInt aStartIndex, TInt aEndIndex, TBool aSync )

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::GetMediasByMpxIdL");

    if ( iCollectionUid.iUid == 0 )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Error, collection must be opened!");

        VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::GetMediasByMpxIdL");

        User::Leave( KErrNotReady );

        }

    if( IsRefreshing() )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Refresh already active.");

        VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::GetMediasByMpxIdL");

        return;

        }

    CMPXCommand* cmd( NULL );

    cmd = CreateMpxCommandLC( KVcxCommandIdMyVideos, KVcxCommandMyVideosGetMediasByMpxId, aSync );    

    CMPXMediaArray* requestedMediaObjects = SelectMediasL( -1, aStartIndex, aEndIndex );

    CleanupStack::PushL( requestedMediaObjects );

    if( requestedMediaObjects )

        {

        cmd->SetCObjectValueL( KMPXMediaArrayContents, requestedMediaObjects );

        cmd->SetTObjectValueL( KMPXMediaArrayCount, requestedMediaObjects->Count() );

        }

    iActionCount++;

    iCollectionUtility->Collection().CommandL( *cmd );

    SetRefreshStatus( ETrue );

    CleanupStack::PopAndDestroy( requestedMediaObjects );

    CleanupStack::PopAndDestroy( cmd );

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::GetMediasByMpxIdL");

    }

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

// CVCXMyVideosCollectionPluginTester::GetMediaFullDetailsL

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

//

void CVCXMyVideosCollectionPluginTester::GetMediaFullDetailsL( TInt aDrive, TInt aIndex )

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::GetMediaFullDetailsL");

    if( GetCurrentLevel() < 2 )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Error. My videos category must be open!");

        User::Leave( KErrGeneral );

        }

    TInt realIndex = GetMediaIndexInCollectionL( aDrive, aIndex );

    RArray<TMPXAttribute> attrs;

    CleanupClosePushL(attrs);

    // Empty attributes to get all the details.

    CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();

    CleanupStack::PushL( path );

    VCXLOGLO2("CVCXMyVideosCollectionPluginTester:: Selecting %d", realIndex);

    path->SelectL( realIndex );

    iCollectionUtility->Collection().MediaL( *path, attrs.Array() );

    CleanupStack::PopAndDestroy( path );

    CleanupStack::PopAndDestroy( &attrs );

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::GetMediaFullDetailsL");

    }

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

// CVCXMyVideosCollectionPluginTester::GetMediaFullDetailsByMpxIdL

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

//

void CVCXMyVideosCollectionPluginTester::GetMediaFullDetailsByMpxIdL( TInt aDrive, TInt aIndex, TBool aSync )

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::GetMediaFullDetailsByMpxIdL");

    if( GetCurrentLevel() < 2 )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Error. My videos category must be open!");

        User::Leave( KErrGeneral );

        }

    TInt realIndex = GetMediaIndexInCollectionL( aDrive, aIndex );

    CMPXMedia* media = media = (*iCollectionMediaArray)[realIndex];

    TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));

    CMPXCommand* cmd( NULL );

    cmd = CreateMpxCommandLC( KVcxCommandIdMyVideos, KVcxCommandMyVideosGetMediaFullDetailsByMpxId, aSync );    

    cmd->SetTObjectValueL( KMPXMediaGeneralId, itemId );    

    iCollectionUtility->Collection().CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::GetMediaFullDetailsByMpxIdL");

    }

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

// CVCXMyVideosCollectionPluginTester::CloseLevelL

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

//

void CVCXMyVideosCollectionPluginTester::CloseLevelL( )

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::CloseLevelL");

    if( GetCurrentLevel() <= 1 )

        {

        VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Error. Cannot go back from root level!");

        User::Leave( KErrGeneral );

        }

    iCurrentOpenedLevelIndex = -1;

    delete iCurrentLevelName;

    iCurrentLevelName = NULL;

    iCollectionUtility->Collection().BackL();

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::CloseLevelL");

    }

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

// CVCXMyVideosCollectionPluginTester::ProcessCurrentEntriesL

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

//

void CVCXMyVideosCollectionPluginTester::ProcessCurrentEntriesL()

    {

    VCXLOGLO1(">>>CVCXMyVideosCollectionPluginTester::ProcessCurrentEntriesL");

    if( GetCurrentLevel() > 0 )

        {

        if( iMediaArray )

            {

            if( !iQuietMode )

                {

                if( !iCurrentLevelName )

                    {

                    PrintMediasL( iMediaArray, ETrue, _L("Collection") );

                    }

                else

                    {

                    PrintMediasL( iMediaArray, ETrue, *iCurrentLevelName );

                    }

                }

            UpdateAlbumsListL();

            }

        else

            {

            VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester:: iMediaArray is NULL");

            }

        }

    VCXLOGLO1("<<<CVCXMyVideosCollectionPluginTester::ProcessCurrentEntriesL");

    }

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

// CVCXMyVideosCollectionPluginTester::PrintMediasL

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

//

void CVCXMyVideosCollectionPluginTester::PrintMediasL( CMPXMediaArray* aMediaArray, TBool aCheckChanges, const TDesC& aTitle )

    {

    if( aMediaArray == NULL )

        {

        aMediaArray = iMediaArray;

        }

    TInt count(0);

    TInt changedCount(0);

    CMPXMediaArray* medias( NULL );

    if( aCheckChanges )

        {

         medias = GetChangedMedias( aMediaArray );

         changedCount = medias->Count();

         count = aMediaArray->Count();

         CleanupStack::PushL( medias );

        }