/*

* 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:   ?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 "VCXTestCommon.h"

#include "VCXTestLog.h"

#include "CIptvTestTimer.h"

#include "CIptvTestActiveWait.h"

#include "VCXTestStatsKeeper.h"

#include "VCXMyVideosCollectionPluginTester.h"

#include "VCXMyVideosTestDlWatcher.h"

#include "VCXMyVideosTestCommon.h"

#include "vcxmyvideoscollection.hrh"

#include "vcxmyvideosmdsdb.h"

#include "vcxmyvideosdefs.h"

// CONSTANTS

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

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

// CVCXMyVideosCollectionPluginTester::NewL

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

//

CVCXMyVideosCollectionPluginTester* CVCXMyVideosCollectionPluginTester::NewL(

            MVCXMyVideosCollectionPluginTesterObserver* aObserver, CVCXTestCommon* aTestCommon, CVCXTestStatsKeeper* aStatsKeeper )

    {

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

    CVCXMyVideosCollectionPluginTester* self = 

        new (ELeave) CVCXMyVideosCollectionPluginTester( aObserver, aTestCommon, aStatsKeeper );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

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

    return self;

    }

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

// CVCXMyVideosCollectionPluginTester::CVCXMyVideosCollectionPluginTester

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

//

CVCXMyVideosCollectionPluginTester::CVCXMyVideosCollectionPluginTester( 

        MVCXMyVideosCollectionPluginTesterObserver* aObserver,

        CVCXTestCommon* aTestCommon, CVCXTestStatsKeeper* aStatsKeeper )

 : iObserver( aObserver ), iTestCommon( aTestCommon ), iStats( aStatsKeeper )

    {

    }

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

// CVCXMyVideosCollectionPluginTester::~CVCXMyVideosCollectionPluginTester

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

//

CVCXMyVideosCollectionPluginTester::~CVCXMyVideosCollectionPluginTester( )

    {

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

    if( iProgressTimer )

        {

        iProgressTimer->CancelTimer();

        delete iProgressTimer;

        iProgressTimer = NULL;

        }

    delete iDlWatcher;

    iDlWatcher = NULL;

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

    iAutomaticContentRefresh = ETrue;

    iActiveWait = CIptvTestActiveWait::NewL();

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

    iTransactions = CVCXMyVideosTestTransactions::NewL();

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

    iDlWatcher = CVCXMyVideosTestDlWatcher::NewL( iObserver, iStats );

    iUpdateDownloads = ETrue;

    iCurrentOpenedLevelIndex = -1;

    iProgressTimer = CIptvTestTimer::NewL( *this, 0 );

    iProgressTimer->After( 1000000 );

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

    TRAP_IGNORE( iStats->ActionStartL( KOpenCollectionActionId, _L("Open collection") ) );

    iCurrentActionHasResponse = EFalse;

    iCurrentActionId = KOpenCollectionActionId;

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

        }

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

        {

        VCXLOGLO2("CVCXMyVideosCollectionPluginTester:: Error. Index (%d) out of bounds!", aIndex);

        User::Leave( KErrGeneral );

        }

    // Save the name of level

    CMPXMedia* media(NULL);

    media = (*iMediaArray)[aIndex];

    if( media->IsSupported( KMPXMediaGeneralTitle ) )

        {

        delete iCurrentLevelName;

        iCurrentLevelName = NULL;

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

        }

    // Open the level

    TRAP_IGNORE( iStats->ActionStartL( KOpenCollectionLevelActionId, _L("Open level") ) );

    iCurrentActionHasResponse = EFalse;

    iCurrentActionId = KOpenCollectionLevelActionId;

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

    TRAP_IGNORE( iStats->ActionStartL( KRefreshCollectionActionId, _L("Refreshing collection") ) );

    iCurrentActionHasResponse = EFalse;

    iCurrentActionId = KRefreshCollectionActionId;

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

        }

    VCXLOGLO1("CVCXMyVideosCollectionPluginTester:: Doing request.");

    iActionCount++;

    TRAP_IGNORE( iStats->ActionStartL( iTransactions->TransactionId(), _L("Get medias by MPX ID") ) );

    iCurrentActionHasResponse = ETrue;

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

    TRAP_IGNORE( iStats->ActionStartL( KGetMediaFullDetailsActionId, _L("Get media full details") ) );

    iCurrentActionHasResponse = EFalse;

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

    TRAP_IGNORE( iStats->ActionStartL( KGetMediaFullDetailsActionId, _L("Get media full details by MPX ID") ) );

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

    iCurrentActionHasResponse = EFalse;

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

                    }

                }

            // Update download states and info

            if( GetCurrentLevel() == 3 && iUpdateDownloads && iDownloadsStarted )

                {

                UpdateDownloadsL( iQuietMode );

                }

            }

        else

            {

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

            }

        }

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

    }

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

// CVcxMyVideosCollectionTester::UpdateDownloadsL

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

//

void CVCXMyVideosCollectionPluginTester::UpdateDownloadsL( TBool aQuietMode )

    {

    if( !iMediaArray || !iDlWatcher )

        {

        return;

        }

    if( !aQuietMode )

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

    iDlWatcher->PrepareCheck();

    // Print short info about downloads

    CMPXMedia* media( NULL );

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

        {

        media = (*iMediaArray)[i];

        // If it's download then get info about it and update download watcher.

        if( media->IsSupported( KVcxMediaMyVideosDownloadState ) )

            {

            TInt state = media->ValueTObjectL<TUint8>( KVcxMediaMyVideosDownloadState );

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

            HBufC* titleBuff = NULL;

            HBufC* urlBuff = NULL;

            HBufC* pathBuff = NULL;

            if( media->IsSupported( KMPXMediaGeneralUri ) )

                {

                const TDesC& url = media->ValueText( KMPXMediaGeneralUri );

                pathBuff = url.AllocL();

                CleanupStack::PushL( pathBuff );

                }

            if( media->IsSupported( KMPXMediaGeneralTitle ) )

                {

                const TDesC& title = media->ValueText( KMPXMediaGeneralTitle );

                titleBuff = title.AllocL();

                CleanupStack::PushL( titleBuff );

                }

            if( media->IsSupported( KVcxMediaMyVideosRemoteUrl ) )

                {

                const TDesC& url = media->ValueText( KVcxMediaMyVideosRemoteUrl );

                urlBuff = url.AllocL();

                CleanupStack::PushL( urlBuff );

                }

            TInt progress = 0;

            if( media->IsSupported( KVcxMediaMyVideosDownloadProgress ) )

                {

                progress = media->ValueTObjectL<TInt8>( KVcxMediaMyVideosDownloadProgress );

                }

            TUint32 downloadId = 0;

            if( media->IsSupported( KVcxMediaMyVideosDownloadId ) )

                {

                downloadId = media->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId );

                }