/*

* 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 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:      Client class for My Videos MPX Collection.*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessage2.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <vcxmyvideosdefs.h>

#include <vcxhgmyvideos.rsg>

#include <vcxmyvideosuids.h>

#include "IptvDebug.h"

#include "vcxhgmyvideoscollectionclient.h"

#include "vcxhgmyvideosdownloadclient.h"

#include "vcxhgmyvideoscategorymodelobserver.h"

#include "vcxhgmyvideosvideomodelobserver.h"

// CONSTANTS

const TInt KVcxHgEventLevelRoot     = 1;

const TInt KVcxHgEventLevelCategory = 2;

const TInt KVcxHgEventLevelVideo    = 3;

const TInt KVcxMpxLevelCategories = 2;

const TInt KVcxMpxLevelVideos     = 3;

const TUint32 KVcxHgMyVideosTransactionId = 5;

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

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

// CVcxHgMyVideosCollectionClient::CVcxHgMyVideosCollectionClient()

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

//

CVcxHgMyVideosCollectionClient::CVcxHgMyVideosCollectionClient()

  : iCollectionOpenStatus( EVcxHgCollectionNotOpen ),

    iPendingCommand( EVcxHgMyVideosCollectionCommandNone )

    {

    }

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

// CVcxHgMyVideosCollectionClient::NewL()

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

//

CVcxHgMyVideosCollectionClient* CVcxHgMyVideosCollectionClient::NewL()

    {

    CVcxHgMyVideosCollectionClient* self = 

    CVcxHgMyVideosCollectionClient::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxHgMyVideosCollectionClient::NewLC()

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

//

CVcxHgMyVideosCollectionClient* CVcxHgMyVideosCollectionClient::NewLC()

    {

    CVcxHgMyVideosCollectionClient* self = 

        new (ELeave) CVcxHgMyVideosCollectionClient();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CVcxHgMyVideosCollectionClient::ConstructL()

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

//

void CVcxHgMyVideosCollectionClient::ConstructL()

    {

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

    iDownloadClient = CVcxHgMyVideosDownloadClient::NewL( *this, *iCollectionUtility );

    }

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

// CVcxHgMyVideosCollectionClient::~CVcxHgMyVideosCollectionClient()

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

//

CVcxHgMyVideosCollectionClient::~CVcxHgMyVideosCollectionClient()

    {

    delete iDownloadClient;

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    }

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

// CVcxHgMyVideosCollectionClient::DownloadClient()

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

//

CVcxHgMyVideosDownloadClient& CVcxHgMyVideosCollectionClient::DownloadClient()

    {

    return *iDownloadClient;

    }

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

// CVcxHgMyVideosCollectionClient::HasPendingCommand()

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

//

TBool CVcxHgMyVideosCollectionClient::HasPendingCommand()

    {

    return iPendingCommand != EVcxHgMyVideosCollectionCommandNone;

    }

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

// CVcxHgMyVideosCollectionClient::SetCategoryModelObserver()

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

//

void CVcxHgMyVideosCollectionClient::SetCategoryModelObserver(

        MVcxHgMyVideosCategoryModelObserver* aCategoryModelObserver )

    {

    iCategoryModelObserver = aCategoryModelObserver;

    }

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

// CVcxHgMyVideosCollectionClient::SetVideoModelObserver()

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

//

void CVcxHgMyVideosCollectionClient::SetVideoModelObserver(

        MVcxHgMyVideosVideoModelObserver* aVideoModelObserver )

    {

    iVideoModelObserver = aVideoModelObserver;

    }

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

// CVcxHgMyVideosCollectionClient::CollectionLevelL()

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

//

TInt CVcxHgMyVideosCollectionClient::CollectionLevelL()

    {

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

    CleanupStack::PushL( path );

    TInt collectionLevel = path->Levels();

    CleanupStack::PopAndDestroy( path );

    return collectionLevel;

    }

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

// CVcxHgMyVideosCollectionClient::GetCategoryListL()

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

//

void CVcxHgMyVideosCollectionClient::GetCategoryListL()

    {

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # GetCategoryListL()" );

    if ( iCollectionOpenStatus == EVcxHgCollectionNotOpen )

        {

        CMPXCollectionPath* collectionPath = CMPXCollectionPath::NewL();

        CleanupStack::PushL( collectionPath );     

        collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

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

        CleanupStack::PopAndDestroy( collectionPath );  

        iCollectionOpenStatus = EVcxHgCollectionOpening;

        }

    else

        {

        if ( CollectionLevelL() == KVcxMpxLevelVideos )

            {

            iCollectionUtility->Collection().BackL();

            }

        }

    }

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

// CVcxHgMyVideosCollectionClient::GetVideoListL()

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

//

void CVcxHgMyVideosCollectionClient::GetVideoListL( TInt aIndex )

    {

    IPTVLOGSTRING2_LOW_LEVEL( 

        "MPX My Videos UI # GetVideoListL(%d)", aIndex );

    TInt collectionLevel = CollectionLevelL();

    if ( collectionLevel == KVcxMpxLevelCategories )

        {    

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

        }

    else if ( collectionLevel == KVcxMpxLevelVideos )

        {

        iCollectionUtility->Collection().BackL();

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

        }

    else

        {

        // NOP

        }

    }

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

// CVcxHgMyVideosCollectionClient::ArrayIndexToMpxItemIdL()

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

//

TMPXItemId CVcxHgMyVideosCollectionClient::ArrayIndexToMpxItemIdL( TInt aArrayIndex,

                                                                   CMPXMediaArray* aArray )

    {

    if ( aArrayIndex < 0 || aArrayIndex >= aArray->Count() )

        {

        User::Leave( KErrArgument );

        }

    return (*aArray)[aArrayIndex]->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

    }

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

// CVcxHgMyVideosCollectionClient::DeleteVideosL()

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

//

void CVcxHgMyVideosCollectionClient::DeleteVideosL( CMPXMediaArray* aMediasToDelete )

    {

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosCollectionClient::DeleteVideosL()" );

    if ( ! HasPendingCommand() && ! iDownloadClient->HasPendingCommand() )

        {

        CMPXCommand* cmd = CMPXMedia::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosDelete );    

        cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse );

        cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, 

                               TUid::Uid( KVcxUidMyVideosMpxCollection ) );

        cmd->SetCObjectValueL( KMPXMediaArrayContents, aMediasToDelete );

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

        iPendingCommand = EVcxHgMyVideosCollectionCommandMultiDelete_Starting;

        CleanupStack::PopAndDestroy( cmd );    

        }

    else

        {

        IPTVLOGSTRING_LOW_LEVEL( 

            "MPX My Videos UI # CVcxHgMyVideosCollectionClient::DeleteVideosL() LEAVE: KErrNotReady" );

        User::Leave( KErrNotReady );

        }

    }

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

// CVcxHgMyVideosCollectionClient::CancelDeleteVideosL()

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

//    

void CVcxHgMyVideosCollectionClient::CancelDeleteVideosL()

    {

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosCollectionClient::CancelDeleteVideosL()" );

    // Deletion can be cancelled right away if deletion has already started. If we

    // are only waiting for it, we modify the pending command to indicate cancellation.

    if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMultiDelete_Started ||

         iPendingCommand == EVcxHgMyVideosCollectionCommandMultiDelete_Finished )

        {

        CMPXCommand* cmd = CMPXMedia::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosCancelDelete );

        cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );

        cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, 

                               TUid::Uid( KVcxUidMyVideosMpxCollection ) );

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

        CleanupStack::PopAndDestroy( cmd );

        iPendingCommand = EVcxHgMyVideosCollectionCommandCancelDelete_Completed;

        }

    else if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMultiDelete_Starting )

        {

        iPendingCommand = EVcxHgMyVideosCollectionCommandCancelDelete_Requested;

        }

    }

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

// CVcxHgMyVideosCollectionClient::MoveOrCopyVideosL()

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

//

void CVcxHgMyVideosCollectionClient::MoveOrCopyVideosL( CMPXMediaArray* mediasToMoveOrCopy,

                                                        TInt aTargetDrive,

                                                        TBool aCopy )

    {

    CMPXCommand* cmd = CMPXMedia::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

    if ( aCopy )

        {

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosCopy );

        }

    else

        {

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosMove );

        }

    cmd->SetTObjectValueL( KVcxMediaMyVideosInt32Value, aTargetDrive );

    cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse );

    cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, 

                           TUid::Uid( KVcxUidMyVideosMpxCollection ) );

    cmd->SetCObjectValueL( KMPXMediaArrayContents, mediasToMoveOrCopy );

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

    iPendingCommand = EVcxHgMyVideosCollectionCommandMoveCopy_Starting;

    CleanupStack::PopAndDestroy( cmd );

    }

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

// CVcxHgMyVideosCollectionClient::CancelMoveOrCopyVideosL()

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

//    

void CVcxHgMyVideosCollectionClient::CancelMoveOrCopyVideosL()

    {

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosCollectionClient::CancelMoveOrCopyVideosL()" );

    if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMoveCopy_Started ||

         iPendingCommand == EVcxHgMyVideosCollectionCommandMoveCopy_Finished )

        {

        CMPXCommand* cmd = CMPXMedia::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosCancelMoveOrCopy );

        cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );

        cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, 

                               TUid::Uid( KVcxUidMyVideosMpxCollection ) );

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

        CleanupStack::PopAndDestroy( cmd );

        iPendingCommand = EVcxHgMyVideosCollectionCommandCancelMoveCopy_Completed;

        }

    else if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMoveCopy_Starting )

        {

        iPendingCommand = EVcxHgMyVideosCollectionCommandCancelMoveCopy_Requested;

        }

    }

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

// CVcxHgMyVideosCollectionClient::PlayVideoL()

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

//

void CVcxHgMyVideosCollectionClient::PlayVideoL( TMPXItemId aMpxItemId )

    {

    IPTVLOGSTRING2_LOW_LEVEL( 

                "CVcxHgMyVideosCollectionClient::PlayVideoL: Play video at collection index %d", aMpxItemId.iId1 );

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL(path);

    path->AppendL( KVcxUidMyVideosMpxCollection );

    path->AppendL( KVcxMvcCategoryIdAll );

    path->AppendL( aMpxItemId );

    path->SelectL( aMpxItemId );

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

    CleanupStack::PopAndDestroy(path);

    }

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

// CVcxHgMyVideosCollectionClient::FetchMpxMediaByMpxIdL()

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

//

void CVcxHgMyVideosCollectionClient::FetchMpxMediaByMpxIdL( TMPXItemId& aMpxId )

    {

    if ( ! iDownloadClient->HasPendingCommand() )

        {    

        CMPXCommand* cmd = CMPXCommand::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosGetMediasByMpxId );

        cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId,

                               TUid::Uid( KVcxUidMyVideosMpxCollection ) );

        cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, KVcxHgMyVideosTransactionId );        

        CMPXMediaArray* idMediaArray = CMPXMediaArray::NewL();

        CleanupStack::PushL( idMediaArray );

        CMPXMedia* media = CMPXMedia::NewL();

        CleanupStack::PushL( media );

        media->SetTObjectValueL( KMPXMessageMediaGeneralId, aMpxId );

        idMediaArray->AppendL( *media );

        CleanupStack::PopAndDestroy( media );

        cmd->SetCObjectValueL<CMPXMediaArray>( KMPXMediaArrayContents, idMediaArray );

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

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

        CleanupStack::PopAndDestroy( idMediaArray );

        CleanupStack::PopAndDestroy( cmd );

        }

    }

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

// CVcxHgMyVideosCollectionClient::GetVideoDetailsL()

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

//

void CVcxHgMyVideosCollectionClient::GetVideoDetailsL( TMPXItemId& aMpxId )

    {

    if ( ! HasPendingCommand() && ! iDownloadClient->HasPendingCommand() )

        {

        CMPXCommand* cmd = CMPXCommand::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );

        cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosGetMediaFullDetailsByMpxId );

        cmd->SetTObjectValueL( KMPXMediaGeneralId, aMpxId );

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

        iPendingCommand = EVcxHgMyVideosCollectionCommandVideoDetails_Requested;

        CleanupStack::PopAndDestroy( cmd );

        }

	}

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

// CVcxHgMyVideosCollectionClient::HandleCollectionMediaL()

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

//

void CVcxHgMyVideosCollectionClient::HandleCollectionMediaL( 

        const CMPXMedia& /*aMedia*/,

        TInt /*aError*/ )

    {

    // No implemetation required.

    }

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

// CVcxHgMyVideosCollectionClient::HandleCollectionMessage()

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

//

void CVcxHgMyVideosCollectionClient::HandleCollectionMessage( 

        CMPXMessage* aMessage,

        TInt aError )

    {

    TRAP_IGNORE( HandleCollectionMessageL( aMessage, aError ) );

    }

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

// CVcxHgMyVideosCollectionClient::HandleCollectionMessageL()

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

//

void CVcxHgMyVideosCollectionClient::HandleCollectionMessageL( 

        CMPXMessage* aMessage,

        TInt aError )

    {

    TInt myVideosCmd( KErrNotFound ); 

    if ( aMessage->ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) == KVcxCommandIdMyVideos )

        {

        myVideosCmd = aMessage->ValueTObjectL<TInt>( KVcxMediaMyVideosCommandId );

        }

    if ( myVideosCmd == KVcxMessageMyVideosMessageArray )

        {

        if ( aMessage->IsSupported( KMPXMessageArrayContents ) )

            {

            const CMPXMessageArray* messageArray =

                aMessage->Value<CMPXMessageArray>(KMPXMessageArrayContents);

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

                {

                HandleSingleCollectionMessageL( (*messageArray)[i], KErrNone );

                }    

            }

        }

    else

        {

        HandleSingleCollectionMessageL( aMessage, aError );

        }

    }

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

// CVcxHgMyVideosCollectionClient::HandleSingleCollectionMessageL()

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

//

void CVcxHgMyVideosCollectionClient::HandleSingleCollectionMessageL( 

        CMPXMessage* aMessage,

        TInt aError )

    {

#ifdef _DEBUG

    if ( aMessage->IsSupported( KVcxMediaMyVideosMessageId ) )

        {

        IPTVLOGSTRING3_LOW_LEVEL(

            "MPX My Videos UI # HandleSingleCollectionMessageL(xxx,%d) MessageId: %d",

            aError,

            static_cast<TUint32>( *( aMessage->Value<TUint32>( KVcxMediaMyVideosMessageId ) ) ) );

        }

    else

#endif // _DEBUG

        {

        IPTVLOGSTRING2_LOW_LEVEL(

            "MPX My Videos UI # HandleSingleCollectionMessageL(xxx,%d)", aError );

        }

    if ( aMessage && aError == KErrNone )

        {

        switch ( *( aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ) ) )

            {

            case KVcxCommandIdMyVideos:

                {

                if ( aMessage->IsSupported( KVcxMediaMyVideosCommandId ) )

                    {

                    TInt mvMsgId = *(aMessage->Value<TInt>( KVcxMediaMyVideosCommandId ) );

                    switch ( mvMsgId )

                        {

                        case KVcxMessageMyVideosGetMediasByMpxIdResp: