/*

* Copyright (c) 2008-2010 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:      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 <centralrepository.h>

#include "IptvDebug.h"

#include "vcxhgmyvideosmodel.h"

#include "vcxhgmyvideosmainview.h"

#include "vcxhgmyvideoscollectionclient.h"

#include "vcxhgmyvideosvideomodelhandler.h"

#include "vcxhgmyvideosvideolistimpl.h"

#include "vcxhgmyvideosvideodataupdater.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 ),

      iRestoreListPosition( EFalse )

    {

    }

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

// CVcxHgMyVideosVideoModelHandler::ConstructL()

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

//

void CVcxHgMyVideosVideoModelHandler::ConstructL()

    {

    iVideoArray = CVcxHgMyVideosVideoList::NewL();

    iDataUpdater = CVcxHgMyVideosVideoDataUpdater::NewL( iModel,

                                                         iScroller,                                                        

    }

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

// Destructor

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

//

CVcxHgMyVideosVideoModelHandler::~CVcxHgMyVideosVideoModelHandler()

    {

    iMarkedMediaList.Close();

    delete iVideoDetails;

    delete iVideoIndicator;

    delete iDataUpdater;

    delete iVideoArray;

	delete iRepository;

    }

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

// CVcxHgMyVideosVideoModelHandler::DoModelActivateL()

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

//

void CVcxHgMyVideosVideoModelHandler::DoModelActivateL()

    {

    IPTVLOGSTRING_LOW_LEVEL( 

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

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

    iModel.CollectionClient().SetVideoModelObserver( NULL );

    iScroller.DisableScrollBuffer();

    TRAP_IGNORE( SaveFirstListItemIdL() );

    IPTVLOGSTRING_LOW_LEVEL( 

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

    }

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

// CVcxHgMyVideosVideoModelHandler::SaveFirstListItemIdL()

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

//

void CVcxHgMyVideosVideoModelHandler::SaveFirstListItemIdL()

    {

    iFirstListItemId = iVideoArray->ArrayIndexToMpxItemIdL(

            iScroller.FirstIndexOnScreen() );

    }

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

// CVcxHgMyVideosVideoModelHandler::UpdateVideoListL()

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

//

void CVcxHgMyVideosVideoModelHandler::UpdateVideoListL( TInt aCategoryIndex )

    {

    IPTVLOGSTRING_LOW_LEVEL( 

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

    CVcxHgMyVideosCollectionClient& collectionClient = iModel.CollectionClient();

    if ( aCategoryIndex == iCurrentCategoryIndex )

        {

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

        // restore the highlight to previous position.

        iRestoreListPosition = ETrue;

        }

    else

        {

        iRestoreListPosition = 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 )

        {

        TVcxMyVideosSortingOrder sortOrder = iModel.VideolistSortOrderL();

        if ( iVideoListImpl.IsMarking() )

            {

            SaveMarkingsL();

            }

        iVideoArray->ResortVideoListL( sortOrder );

        TInt highlight = iScroller.SelectedIndex();

        ResetScrollerBufferAndItemsL();

        iScroller.SetSelectedIndex( highlight );

        iView.DynInitMskL();

        if ( iVideoListImpl.IsMarking() )

            {

            RestoreMarkingsL();

            }

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

    {

    CMPXMedia* media = iVideoArray->MPXMediaByMPXItemId( TMPXItemId( aId, 0 ) );

    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::GetVideoId()

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

//

TInt CVcxHgMyVideosVideoModelHandler::GetVideoId( TInt aIndex )

    {

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

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

        {

        return media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ).iId1;

        }

    return KErrNotFound;

    }

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

// 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->MPXMediaByMPXItemId( TMPXItemId(aOperationTargets[i],0) );

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