/*

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

*

*/

// 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 "VCXTestLog.h"

#include "VCXMyVideosCollectionPluginTester.h"

#include "VCXMyVideosTestCommon.h"

#include "vcxmyvideoscollection.hrh"

#include "vcxmyvideosmdsdb.h"

#include "vcxmyvideosdefs.h"

// CONSTANTS

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

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

// CVCXMyVideosCollectionPluginTester::NewL

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

//

CVCXMyVideosCollectionPluginTester* CVCXMyVideosCollectionPluginTester::NewL(

    {

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

    CVCXMyVideosCollectionPluginTester* self = 

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

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

    return self;

    }

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

// CVCXMyVideosCollectionPluginTester::CVCXMyVideosCollectionPluginTester

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

//

CVCXMyVideosCollectionPluginTester::CVCXMyVideosCollectionPluginTester( 

        MVCXMyVideosCollectionPluginTesterObserver* aObserver,

    {

    }

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

// 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 )

        {

        iMediaArray->Reset();

        delete iMediaArray;

        iMediaArray = 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;

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

    }

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

// CVCXMyVideosCollectionPluginTester::ConstructL

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

//

void CVCXMyVideosCollectionPluginTester::ConstructL()

    {

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

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

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

    CleanupStack::PopAndDestroy( path );

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

    }

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

// 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 );

        }

        {

        }

        {

        }

    // Open the level

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

    iCurrentOpenedLevelIndex = aIndex;

    SetRefreshStatus( ETrue );

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

    }

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

// CVCXMyVideosCollectionPluginTester::RefreshContentsL

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

//

void CVCXMyVideosCollectionPluginTester::RefreshContentsL()

    {

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

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

    if( GetCurrentLevel() != 3)

        {

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

        return;

        }

    // 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 );

                    }

                }

            }

        else

            {

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

            }

        }

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

    }

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

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

//

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

        }