/*

* 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:      UI level handler for video data.*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediageneralextdefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <ganes/HgScroller.h>

#include <ganes/HgItem.h>

#include <vcxhgmyvideos.rsg>

#include <vcxmyvideosdefs.h>

#include <MPFileDetailsDialog.h>

#include <myvideosindicator.h>

#include "IptvDebug.h"

#include "vcxhgmyvideosmodel.h"

#include "vcxhgmyvideosmainview.h"

#include "vcxhgmyvideoscollectionclient.h"

#include "vcxhgmyvideosdownloadclient.h"

#include "vcxhgmyvideosvideomodelhandler.h"

#include "vcxhgmyvideosvideolistimpl.h"

#include "vcxhgmyvideosvideodataupdater.h"

#include "vcxhgmyvideosdownloadupdater.h"

#include "vcxhgmyvideos.hrh"

#include "vcxhgmyvideoslistbase.h"

#include "vcxhgmyvideosindicatorhelper.h"

#include "vcxhgmyvideosvideodetailsdialog.h"

#include "vcxhgmyvideosvideolist.h"

#include "vcxhgmyvideospanics.h"

// CONSTANTS

const TUint KVcxSecondsInMinute( 60 );

const TUint KVcxSecondsInHour( 3600 );

const TUint KVcxVideoSizeGB( 0x40000000 );

const TUint KVcxVideoSizeHalfGB( 0x20000000 );

const TUint KVcxVideoSizeMB( 0x100000 );

const TUint KVcxVideoSizeHalfMB( 0x80000 );

const TUint KVcxVideoSizeKB( 0x400 );

const TUint KVcxVideoSizeHalfKB( 0x200 ); 

const TUint KHgBufferSize( 250 );

const TUint KHgBufferTreshold( 50 );

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

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

// CVcxHgMyVideosVideoModelHandler::NewL()

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

//

CVcxHgMyVideosVideoModelHandler* CVcxHgMyVideosVideoModelHandler::NewL( 

        CVcxHgMyVideosVideoListImpl& aVideoListImpl,

        CVcxHgMyVideosModel& aModel,

        CVcxHgMyVideosMainView& aView,

        CHgScroller& aScroller )        

    {

    CVcxHgMyVideosVideoModelHandler* self = 

        CVcxHgMyVideosVideoModelHandler::NewLC( 

            aVideoListImpl, aModel, aView, aScroller );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxHgMyVideosVideoModelHandler::NewLC()

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

//

CVcxHgMyVideosVideoModelHandler* CVcxHgMyVideosVideoModelHandler::NewLC(

        CVcxHgMyVideosVideoListImpl& aVideoListImpl,

        CVcxHgMyVideosModel& aModel,

        CVcxHgMyVideosMainView& aView,

        CHgScroller& aScroller )        

    {

    CVcxHgMyVideosVideoModelHandler* self = 

        new (ELeave) CVcxHgMyVideosVideoModelHandler( 

            aVideoListImpl, aModel, aView, aScroller );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Constructor

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

//

CVcxHgMyVideosVideoModelHandler::CVcxHgMyVideosVideoModelHandler(

        CVcxHgMyVideosVideoListImpl& aVideoListImpl,

        CVcxHgMyVideosModel& aModel,

        CVcxHgMyVideosMainView& aView,

        CHgScroller& aScroller )

    : iVideoListImpl( aVideoListImpl ),

      iModel( aModel ),

      iView( aView ),

      iScroller( aScroller ),

      iCurrentCategoryIndex( KErrNotFound ),

      iRestoreHighlightPosition( EFalse )

    {

    }

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

// CVcxHgMyVideosVideoModelHandler::ConstructL()

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

//

void CVcxHgMyVideosVideoModelHandler::ConstructL()

    {

    iVideoArray = CVcxHgMyVideosVideoList::NewL();

    iDataUpdater = CVcxHgMyVideosVideoDataUpdater::NewL( iModel,

                                                         iScroller,                                                        

                                                         *iVideoArray );

    iDownloadUpdater = CVcxHgMyVideosDownloadUpdater::NewL( *this, *iVideoArray );

    iVideoIndicator = CMyVideosIndicator::NewL();

    }

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

// Destructor

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

//

CVcxHgMyVideosVideoModelHandler::~CVcxHgMyVideosVideoModelHandler()

    {

    iResumeArray.Close();

    delete iVideoIndicator;

    delete iDataUpdater;

    delete iDownloadUpdater;

    delete iVideoArray;

    }

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

// CVcxHgMyVideosVideoModelHandler::DoModelActivateL()

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

//

void CVcxHgMyVideosVideoModelHandler::DoModelActivateL()

    {

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosVideoModelHandler::DoModelActivateL() - Enter" );

    iDataUpdater->SetPausedL( EFalse );

    iDownloadUpdater->SetPausedL( EFalse );

    iModel.CollectionClient().SetVideoModelObserver( this );

    // Set scroller strip type

    TVcxMyVideosSortingOrder sortOrder = iModel.VideolistSortOrderL();

    UpdateScrollbarTypeL( sortOrder );

    // Set up scroll buffer

    iScroller.EnableScrollBufferL( *this, KHgBufferSize, KHgBufferTreshold ); 

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosVideoModelHandler::DoModelActivateL() - Exit" );    

    }

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

// CVcxHgMyVideosVideoModelHandler::DoModelDeactivate()

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

//

void CVcxHgMyVideosVideoModelHandler::DoModelDeactivate()

    {

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosVideoModelHandler::DoModelDeactivate() - Enter" );

    TRAP_IGNORE( iDataUpdater->SetPausedL( ETrue ) );

    TRAP_IGNORE( iDownloadUpdater->SetPausedL( ETrue ) );

    iModel.CollectionClient().SetVideoModelObserver( NULL );

    iScroller.DisableScrollBuffer();

    TRAP_IGNORE( SaveHighlightedItemIdL() );

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosVideoModelHandler::DoModelDeactivate() - Exit" );    

    }

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

// CVcxHgMyVideosVideoModelHandler::SaveHighlightedItemIdL()

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

//

void CVcxHgMyVideosVideoModelHandler::SaveHighlightedItemIdL()

    {    

    iHighlightedItemId = iVideoArray->ArrayIndexToMpxItemIdL( Highlight() );

    }

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

// CVcxHgMyVideosVideoModelHandler::UpdateVideoListL()

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

//

void CVcxHgMyVideosVideoModelHandler::UpdateVideoListL( TInt aCategoryIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosVideoModelHandler::UpdateVideoListL() - Enter" );

    CVcxHgMyVideosCollectionClient& collectionClient = iModel.CollectionClient();

    // If we are re-opening the same video list again, then try 

    // restore the highlight to previous position.

    aCategoryIndex == iCurrentCategoryIndex ? iRestoreHighlightPosition = ETrue :

                                              iRestoreHighlightPosition = EFalse;

    // Removes videos from video list.

    iVideoArray->RemoveVideoList();

    // Removes videos from scroller. After this command, list highlight 

    // disappears, so don't forget to set highlight in NewVideoListL() 

    // function.

    iScroller.Reset();

    // Ask for video list from MPX collection.

    collectionClient.GetVideoListL( aCategoryIndex );

    iCurrentCategoryIndex = aCategoryIndex;

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # CVcxHgMyVideosVideoModelHandler::UpdateVideoListL() - Exit" );    

    }

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

// CVcxHgMyVideosVideoModelHandler::ResortVideoListL()

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

//

void CVcxHgMyVideosVideoModelHandler::ResortVideoListL()

    {    

    IPTVLOGSTRING_LOW_LEVEL( 

        "MPX My Videos UI # ResortVideoListL() - Enter" );

    if ( iScroller.ItemCount() > 0 )

        {

        iDownloadUpdater->SetPausedL( ETrue );

        TVcxMyVideosSortingOrder sortOrder = iModel.VideolistSortOrderL();

        iVideoArray->ResortVideoListL( sortOrder );

        TInt highlight = iScroller.SelectedIndex();

        iScroller.SetSelectedIndex( highlight );

        iView.DynInitMskL();

        iDownloadUpdater->VideoArrayChangedL();

        iDownloadUpdater->SetPausedL( EFalse );

        // Switch to appropriate scroller strip

        UpdateScrollbarTypeL( sortOrder );

        }

        IPTVLOGSTRING_LOW_LEVEL( 

            "MPX My Videos UI # ResortVideoListL() - Exit" );

    }

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

// CVcxHgMyVideosVideoModelHandler::Highlight()

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

//

TInt CVcxHgMyVideosVideoModelHandler::Highlight()

    {

    return iScroller.SelectedIndex();

    }

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

// CVcxHgMyVideosVideoModelHandler::VideoCount()

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

//

TInt CVcxHgMyVideosVideoModelHandler::VideoCount()

    {

    return iScroller.ItemCount();

    }

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

// CVcxHgMyVideosVideoModelHandler::CurrentCategoryIndex() 

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

//

TInt CVcxHgMyVideosVideoModelHandler::CurrentCategoryIndex()

    {

    return iCurrentCategoryIndex;

    }

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

// CVcxHgMyVideosVideoModelHandler::MarkedVideosL()

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

//

void CVcxHgMyVideosVideoModelHandler::MarkedVideosL( 

        RArray<TInt>& aMarkedVideos )

    {

    iScroller.GetMarkedItemsL( aMarkedVideos );

    }

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

// CVcxHgMyVideosVideoModelHandler::OngoingDownloads()

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

//

void CVcxHgMyVideosVideoModelHandler::OngoingDownloads(

        RArray<TInt>& aDownloads )

    {

    iVideoArray->GetOngoingDownloads( aDownloads );

    }

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

// CVcxHgMyVideosVideoModelHandler::VideoDownloadState()

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

//

TVcxMyVideosDownloadState CVcxHgMyVideosVideoModelHandler::VideoDownloadState( 

        TInt aIndex )

    {

    return iVideoArray->VideoDownloadState( aIndex );

    }

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

// CVcxHgMyVideosVideoModelHandler::IsProgressivePlayPossible()

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

//

TBool CVcxHgMyVideosVideoModelHandler::IsProgressivePlayPossible( TInt aIndex )

    {

    return iDownloadUpdater->IsPlayPossible( aIndex );

    }

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

// CVcxHgMyVideosVideoModelHandler::HandleMarkCommandL()

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

//

void CVcxHgMyVideosVideoModelHandler::HandleMarkCommandL( TInt aMarkCommand )

    {

    switch ( aMarkCommand )

        {

        case EVcxHgMyVideosCmdMark:

            {

            TInt highlight = Highlight();

            iScroller.Mark( highlight );

            iScroller.RefreshScreen( highlight );

            }

            break;

        case EVcxHgMyVideosCmdUnmark:

            {

            TInt highlight = Highlight();

            iScroller.UnMark( highlight );

            iScroller.RefreshScreen( highlight );

            }            

            break;

        case EVcxHgMyVideosCmdMarkAll:

            {

            iScroller.MarkAll();

            }

            break;

        case EVcxHgMyVideosCmdUnmarkAll:

            {

            iScroller.UnMarkAll();

            }

            break;

        default:

            {

            IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # HandleMarkCommandL - LEAVE: Invalid mark command" );

            User::Leave( KErrNotSupported );

            }

            break;

        }

    }

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

// CVcxHgMyVideosVideoModelHandler::VideoAgeProfileL()

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

//

TInt32 CVcxHgMyVideosVideoModelHandler::VideoAgeProfileL( TInt aIndex )

    {

    return VideoAgeProfileL( iVideoArray->MPXMedia( aIndex ) );

    }

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

// CVcxHgMyVideosVideoModelHandler::VideoAgeProfileL()

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

//

TInt32 CVcxHgMyVideosVideoModelHandler::VideoAgeProfileL( TMPXItemId aId )

    {

    return VideoAgeProfileL( iVideoArray->MPXMediaByMPXItemId( aId ) );

    }

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

// CVcxHgMyVideosVideoModelHandler::VideoAgeProfileL()

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

//

TInt32 CVcxHgMyVideosVideoModelHandler::VideoAgeProfileL( CMPXMedia* aMedia )

    {

    TInt32 ageProfile( 0 );

    if ( aMedia )

        {

        if ( aMedia->IsSupported( KVcxMediaMyVideosAgeProfile ) )

            {

            ageProfile = aMedia->ValueTObjectL<TInt32>( KVcxMediaMyVideosAgeProfile );

            }

        }

    return ageProfile;

    }

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

// CVcxHgMyVideosVideoModelHandler::FindVideoMpxIdL()

// Tries to find MPX Item Id based on URI. Does not modify MPX Item Id's initial

// value if video not found.

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

//

TBool CVcxHgMyVideosVideoModelHandler::FindVideoMpxIdL( const TDesC& aVideoPath,

                                                        TMPXItemId& aMpxItemId )

    {

    CMPXMedia* media = iVideoArray->MPXMediaByUri( aVideoPath );

    if ( media )

        {

        if ( media->IsSupported( KMPXMediaGeneralId ) )

            {

            aMpxItemId = media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CVcxHgMyVideosVideoModelHandler::ShowVideoDetailsDialogL()

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

//

void CVcxHgMyVideosVideoModelHandler::ShowVideoDetailsDialogL()

    {

    TInt highlight = Highlight();

    if ( highlight != KErrNotFound )

        {

        TMPXItemId mpxItemId = iVideoArray->ArrayIndexToMpxItemIdL( highlight );

        iModel.CollectionClient().GetVideoDetailsL( mpxItemId );        

        }

    }

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

// 

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

//

CMyVideosIndicator& CVcxHgMyVideosVideoModelHandler::VideoIndicator()

    {

    return *iVideoIndicator;

    }

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

// CVcxHgMyVideosVideoModelHandler::GetVideoName()

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

//

const TDesC& CVcxHgMyVideosVideoModelHandler::GetVideoName( TInt aIndex )

    {

    CMPXMedia* media = iVideoArray->MPXMedia( aIndex );

    if ( media && media->IsSupported( KMPXMediaGeneralTitle ) )

        {

        return media->ValueText( KMPXMediaGeneralTitle );

        }

    return KNullDesC;

    }

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

// CVcxHgMyVideosVideoModelHandler::GetVideoUri()

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

//

const TDesC& CVcxHgMyVideosVideoModelHandler::GetVideoUri( TInt aIndex )

    {

    CMPXMedia* media = iVideoArray->MPXMedia( aIndex );

    if ( media && media->IsSupported( KMPXMediaGeneralUri ) )

        {

        return media->ValueText( KMPXMediaGeneralUri );

        }

    return KNullDesC;

    }

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

// CVcxHgMyVideosVideoModelHandler::GetVideoSize()

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

//

TInt64 CVcxHgMyVideosVideoModelHandler::GetVideoSize( TInt aIndex )

    {

    CMPXMedia* media = iVideoArray->MPXMedia( aIndex );

    if ( media && media->IsSupported( KMPXMediaGeneralExtSizeInt64 ) )

        {

        return media->ValueTObjectL<TInt64>( KMPXMediaGeneralExtSizeInt64 );

        }

    return 0;

    }

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

// CVcxHgMyVideosVideoModelHandler::DeleteVideosL()

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

//

void CVcxHgMyVideosVideoModelHandler::DeleteVideosL( 

        const RArray<TInt>& aOperationTargets )

    {

    CMPXMedia* media = NULL;

    TMPXItemId mpxItemId;

    CMPXMedia* mediaToDelete = NULL;

    CMPXMediaArray* mediasToDelete = CMPXMediaArray::NewL();

    CleanupStack::PushL( mediasToDelete );

    for ( TInt i = 0; i < aOperationTargets.Count(); i++ )

        {

        media = iVideoArray->MPXMedia( aOperationTargets[i] );

        if ( media && media->IsSupported( KMPXMediaGeneralId ) )

            {

            mpxItemId = media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

            mediaToDelete = CMPXMedia::NewL();

            CleanupStack::PushL( mediaToDelete );

            mediaToDelete->SetTObjectValueL( KMPXMediaGeneralId, mpxItemId );

            mediasToDelete->AppendL( *mediaToDelete );

            CleanupStack::PopAndDestroy( mediaToDelete );