/*

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

*/

// INCLUDE FILES

#include <mpxmediaarray.h>

#include <mpxmedia.h>

#include <mpxmediageneraldefs.h>

#include <ganes/HgScroller.h>

#include <ganes/HgItem.h>

#include <thumbnailmanager.h>

#include <thumbnailmanagerobserver.h>

#include <thumbnailobjectsource.h>

#include <thumbnaildata.h>

#include <DRMCommon.h> // DRM

#include <gulicon.h>

#include "IptvDebug.h"

#include <myvideosindicator.h>

#include <vcxmyvideosdefs.h>

#include "vcxhgmyvideosmodel.h"

#include "vcxhgmyvideosmainview.h"

#include "vcxhgmyvideosvideolist.h"

#include "vcxhgmyvideosvideodataupdater.h"

#include "vcxhgmyvideosindicatorhelper.h"

#include "vcxhgmyvideosthumbnailmanager.h"

const TInt KRefreshTimerInterval( 1000000 );    // 1 second

const TInt KMaxThumbnailReqs( 2 );              // Max count of peek and get reqs combined

const TInt KMaxThumbnailGetReqs( 1 );           // Max count of get reqs

const TInt KMaxPredictiveSelect( 10 );          // Max range for selecting items before/after visible area

const TInt KScrollCheckInterval( 250000 );      // 0.25 seconds

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

// TimeStamp

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

//

static TInt64 TimeStamp()

    {

    TTime time;

    time.UniversalTime();

    return time.Int64();

    }

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

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

// CVcxHgMyVideosVideoDataUpdater::NewL()

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

//

CVcxHgMyVideosVideoDataUpdater* CVcxHgMyVideosVideoDataUpdater::NewL(

        CVcxHgMyVideosModel& aModel,

        CHgScroller& aScroller,

        CVcxHgMyVideosVideoList& aVideoArray,

        CMyVideosIndicator& aVideosIndicator )

    {

    CVcxHgMyVideosVideoDataUpdater* self = 

        CVcxHgMyVideosVideoDataUpdater::NewLC( aModel,

                                               aScroller,

                                               aVideoArray,

                                               aVideosIndicator );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxHgMyVideosVideoDataUpdater::NewLC()

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

//

CVcxHgMyVideosVideoDataUpdater* CVcxHgMyVideosVideoDataUpdater::NewLC(

        CVcxHgMyVideosModel& aModel,

        CHgScroller& aScroller,

        CVcxHgMyVideosVideoList& aVideoArray,

        CMyVideosIndicator& aVideosIndicator)

    {

    CVcxHgMyVideosVideoDataUpdater* self = 

        new (ELeave) CVcxHgMyVideosVideoDataUpdater( aModel,

                                                     aScroller,

                                                     aVideoArray,

                                                     aVideosIndicator );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CVcxHgMyVideosVideoDataUpdater::CVcxHgMyVideosVideoDataUpdater()

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

//

CVcxHgMyVideosVideoDataUpdater::CVcxHgMyVideosVideoDataUpdater(

        CVcxHgMyVideosModel& aModel,

        CHgScroller& aScroller,

        CVcxHgMyVideosVideoList& aVideoArray,

        CMyVideosIndicator& aVideosIndicator )

  : CActive( EPriorityStandard ),

    iModel( aModel ),

    iScroller( aScroller ),

    iVideoArray( aVideoArray ),

    {

    CActiveScheduler::Add( this );

    }

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

// CVcxHgMyVideosVideoDataUpdater::ConstructL()

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

//

void CVcxHgMyVideosVideoDataUpdater::ConstructL()

    {

    iRefreshTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iRetryTimer =   CPeriodic::NewL( CActive::EPriorityStandard );

    iModel.ThumbnailManager().AddObserverL( *this );

    }

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

// CVcxHgMyVideosVideoDataUpdater::InfoArrayChanged()

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

// 

void CVcxHgMyVideosVideoDataUpdater::InfoArrayChanged()

    {

    // Can we optimise this? Many times new video list contains lot of items

    // from the old one. But how to make sure there isn't any radical changes...

    CancelAndDeleteFetchArray();

    }

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

// CVcxHgMyVideosVideoDataUpdater::~CVcxHgMyVideosVideoDataUpdater()

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

//

CVcxHgMyVideosVideoDataUpdater::~CVcxHgMyVideosVideoDataUpdater()

    {

    iModel.ThumbnailManager().RemoveObserver( *this );

    Cancel();

    delete iRefreshTimer; // Cancels active timer

    delete iRetryTimer;

    iFetchArray.ResetAndDestroy();

    }

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

// CVcxHgMyVideosVideoDataUpdater::SetPausedL()

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

//

void CVcxHgMyVideosVideoDataUpdater::SetPausedL( TBool aPaused )

    {

    iPaused = aPaused;

    if ( ! iPaused )

        {

        ContinueVideoDataFetchingL();

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::RequestDataL()

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

//

void CVcxHgMyVideosVideoDataUpdater::RequestDataL( TMPXItemId aMPXItemId )

    {

    AddItemToFetchArrayL( aMPXItemId );

    ContinueVideoDataFetchingL();

    }

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

// CVcxHgMyVideosVideoDataUpdater::AddToRequestBufferL()

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

//

void CVcxHgMyVideosVideoDataUpdater::AddToRequestBufferL( TMPXItemId aMPXItemId )

    {

    AddItemToFetchArrayL( aMPXItemId );

    }

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

// CVcxHgMyVideosVideoDataUpdater::FlushRequestBufferL()

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

//

void CVcxHgMyVideosVideoDataUpdater::FlushRequestBufferL()

    {

    ContinueVideoDataFetchingL();

    }

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

// CVcxHgMyVideosVideoDataUpdater::ReleaseData()

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

//

void CVcxHgMyVideosVideoDataUpdater::ReleaseData( TMPXItemId aMPXItemId )

    {

    TInt index = IndexByMPXItemId( aMPXItemId );

    if ( index >= 0 )

        {

        RemoveItem( index ); 

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::PrepareForMoveOrDelete()

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

//

void CVcxHgMyVideosVideoDataUpdater::PrepareForMoveOrDelete( TMPXItemId aMPXItemId )

    {

    TInt index = IndexByMPXItemId( aMPXItemId );

    if ( index >= 0 )

        {

        RemoveAndCancelThumbnailGeneration( index ); 

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::RemoveAndCancelThumbnailGeneration()

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

//

void CVcxHgMyVideosVideoDataUpdater::RemoveAndCancelThumbnailGeneration( TInt aIndex )

    {

    if ( aIndex >= 0 && aIndex < iFetchArray.Count() )

        {

        // Can be enabled when cancellation of (hd) thumbnail gets faster and

        // does not hang up UI

        CancelActivities( aIndex );

        delete iFetchArray[aIndex];

        iFetchArray.Remove( aIndex );

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::RemoveItem()

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

//

void CVcxHgMyVideosVideoDataUpdater::RemoveItem( TInt aIndex )

    {

    if ( aIndex >= 0 && aIndex < iFetchArray.Count() )

        {    

        CVcxHgMyVideosVideoData* item = iFetchArray[aIndex];

        // When scrolling around canceling thumbnail creation is sometimes so slow

        // that it hangs UI for while. Thumbnail is needed sooner or later anyway.

        // Therefore let creation get finished in peace. It is possible to fetch already 

        // created thumbs during creation but not during hang up. 

        if ( item && !CancelNeeded( *item ) )

            {

            delete item;

            iFetchArray.Remove( aIndex );

            }         

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::AddItemToFetchArrayL()

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

//

void CVcxHgMyVideosVideoDataUpdater::AddItemToFetchArrayL( TMPXItemId aMPXItemId )

    {

    CVcxHgMyVideosVideoData* newItem = CVcxHgMyVideosVideoData::NewLC();

    newItem->SetMPXItemId( aMPXItemId );

    iFetchArray.AppendL( newItem );   

    CleanupStack::Pop( newItem );

    }

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

// CVcxHgMyVideosVideoDataUpdater::CancelActivities()

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

//

void CVcxHgMyVideosVideoDataUpdater::CancelActivities( TInt aIndex )

    {    

    if ( aIndex >= 0 && aIndex < iFetchArray.Count() )

        {

        CVcxHgMyVideosVideoData* item = iFetchArray[aIndex];

        if ( item && CancelNeeded( *item ) )

            {

            iModel.ThumbnailManager().Cancel( item->ThumbnailConversionId() );

            }

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::CancelAndDeleteFetchArray()

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

//

void CVcxHgMyVideosVideoDataUpdater::CancelAndDeleteFetchArray()

    {

    TInt count = iFetchArray.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        CancelActivities( i );

        }

    iFetchArray.ResetAndDestroy();

    iPreviousFirstScrollerIndexTime = 0;

    iPreviousFirstScrollerIndex = iScroller.FirstIndexOnScreen();

    iPreviousModifiedIndexOnScreen = EFalse;

    }

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

// CVcxHgMyVideosVideoDataUpdater::ContinueVideoDataFetchingL()

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

//

void CVcxHgMyVideosVideoDataUpdater::ContinueVideoDataFetchingL()

    {

    iRetryTimer->Cancel();

    if ( !iPaused && iVideoArray.VideoCount() > 0 && iFetchArray.Count() > 0 )

        {

        TInt64 time = TimeStamp();

        TBool refreshTimerNeeded = EFalse;

        TInt peekReqs = 0;

        TInt getReqs = 0;

        GetActiveRequestCount( peekReqs, getReqs );

        TInt reqs = peekReqs + getReqs;

        if ( reqs < KMaxThumbnailReqs )

            {

            CVcxHgMyVideosVideoData::TVideoDataState state =

                        CVcxHgMyVideosVideoData::EVideoDataStateNone;

            CVcxHgMyVideosVideoData* prevItem = NULL;

            CVcxHgMyVideosVideoData* item = NULL;

            do

                {

                TInt err = KErrNone;

                prevItem = item;

                if ( !SelectNextIndexL( getReqs >= KMaxThumbnailGetReqs ) )

                    {

                    // Nothing to be started

                    if ( !reqs && iFetchArray.Count() > 0 )

                        {

                        // To ensure that thumbnail creation continues after

                        // disabled while scrolling

                        iRetryTimer->Start( KScrollCheckInterval, KScrollCheckInterval,

                            TCallBack( RetryTimerCallBack, this ) );

                        iPreviousFirstScrollerIndexTime = 0; // Force scroll check update

                        IPTVLOGSTRING_LOW_LEVEL(

                           "MPX My Videos UI # ContinueVideoDataFetchingL # iRetryTimer start" );

                        }

                    break;

                    }

                item = iFetchArray[0];

                state = item->State();

                if ( state == CVcxHgMyVideosVideoData::EVideoDataStateNone )

                    {

                    // Try first a quick peek with thumbnail creation denied

                    TRAP( err, StartThumbnailL( *item, ETrue ) );

                    if( err == KErrNone )

                        {

                        ++reqs;

                        refreshTimerNeeded = ETrue;

                        }

                    }

                else if ( state == CVcxHgMyVideosVideoData::EVideoDataStateThumbnailPeekFinished ) 

                    {

                    if ( getReqs < KMaxThumbnailGetReqs )

                        {

                        // Try then get with thumbnail creation allowed

                        TRAP( err, StartThumbnailL( *item, EFalse ) );

                        if ( err == KErrNone )

                            {

                            ++reqs;

                            ++getReqs;

                            refreshTimerNeeded = ETrue;

                            }

                        }

                    }

                if ( err != KErrNone )

                    {

                    RemoveItem( 0 );

                    }                

                }

            while ( iFetchArray.Count() > 0 && reqs < KMaxThumbnailReqs && prevItem != item );

            }

        if ( refreshTimerNeeded && !iRefreshTimer->IsActive() )

            {

            iRefreshTimer->Start( KRefreshTimerInterval, KRefreshTimerInterval,

                TCallBack( RefreshTimerCallBack, this ) );

            IPTVLOGSTRING_LOW_LEVEL(

               "MPX My Videos UI # ContinueVideoDataFetchingL # iRefreshTimer start" );

            }

        if ( time - iPreviousFirstScrollerIndexTime >= KScrollCheckInterval )

            {

            // Store values for scroll direction check

            iPreviousFirstScrollerIndexTime = time;

            iPreviousFirstScrollerIndex = iScroller.FirstIndexOnScreen();

            }

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::UpdateVideoDataToUiL()

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

//

void CVcxHgMyVideosVideoDataUpdater::UpdateVideoDataToUiL( CVcxHgMyVideosVideoData& aVideoData )

    {

    IPTVLOGSTRING_LOW_LEVEL("CVcxHgMyVideosVideoDataUpdater::UpdateVideoDataToUiL() ENTER" );

    TInt index = iVideoArray.IndexByMPXItemId( aVideoData.MPXItemId() );

    if ( index >= 0 && index < iScroller.ItemCount() )

        {       

        TBool drmUpdate = aVideoData.DrmProtected();

        CHgItem& listItem = iScroller.ItemL( index );

        if ( aVideoData.Thumbnail() )

            {

            CGulIcon* thumbnail = CGulIcon::NewL( aVideoData.Thumbnail( ETrue ) );

            listItem.SetIcon( thumbnail );

            CMPXMedia* media = iVideoArray.MPXMediaByMPXItemId( aVideoData.MPXItemId() );

            if ( iVideosIndicator.IsIndicatorShown( *media ) )

                {

                IPTVLOGSTRING_LOW_LEVEL("CVcxHgMyVideosVideoDataUpdater::UpdateVideoDataToUiL() has icon, has indicator" );

                listItem.SetFlags( CHgItem::EHgItemFlagsIconOverlayIndicator );

                }

            else

                {

                IPTVLOGSTRING_LOW_LEVEL("CVcxHgMyVideosVideoDataUpdater::UpdateVideoDataToUiL() has icon, no indicator" );

                listItem.ClearFlags( CHgItem::EHgItemFlagsIconOverlayIndicator );

                }

            }

        if ( drmUpdate )

            {

            TVcxHgMyVideosIndicatorHelper::TIndicatorDrmStatus drmStatus;

            CMPXMedia* media = iVideoArray.MPXMedia( index );

            if ( media )

                {

                TVcxHgMyVideosIndicatorHelper indicatorHelper;

                TInt indicator1( 0 );

                TInt indicator2( 0 );

                if ( aVideoData.ValidDrmRights() )

                    {

                    drmStatus = TVcxHgMyVideosIndicatorHelper::EIndicatorDrmStatusValid;

                    }

                else

                    {

                    drmStatus = TVcxHgMyVideosIndicatorHelper::EIndicatorDrmStatusExpired;

                    }

                TBool isNewVideo( EFalse );

                if ( media->IsSupported( KMPXMediaGeneralFlags ) )

                    {

                    if ( media->ValueTObjectL<TUint32>( KMPXMediaGeneralFlags ) &

                        EVcxMyVideosVideoNew )

                        {

                        isNewVideo = ETrue;

                        }

                    }                    

                indicatorHelper.GetIndicatorsForVideoL(

                    iModel,

                    isNewVideo,

                    EFalse, // *Recordings*

                    media->ValueText( KMPXMediaGeneralUri ),

                    drmStatus,

                    indicator1,

                    indicator2 );

                if ( indicator1 )

                    {

                    listItem.SetFlags( indicator1 );

                    }

                if ( indicator2 )

                    {

                    listItem.SetFlags( indicator2 );

                    }

                }

            }

        if ( ListRefreshNeeded( index ) )

            {

            RefreshScreen();

            }

        }

    IPTVLOGSTRING_LOW_LEVEL("CVcxHgMyVideosVideoDataUpdater::UpdateVideoDataToUiL() RETURN" );

    }

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

// CVcxHgMyVideosVideoDataUpdater::IndexByMPXItemId()

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

//

TInt CVcxHgMyVideosVideoDataUpdater::IndexByMPXItemId( TMPXItemId aMPXItemId )

    {   

    TInt count = iFetchArray.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        if ( iFetchArray[i]->MPXItemId() == aMPXItemId )

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// CVcxHgMyVideosVideoDataUpdater::SelectNextIndexL()

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

// 

TBool CVcxHgMyVideosVideoDataUpdater::SelectNextIndexL( TBool aSelectForPeekOnly )

    {

    TBool selected = EFalse;

    if ( iScroller.ItemCount() > 0 )

        {

        TInt firstIndexOnScreen = 0;

        TInt lastIndexOnScreen = 0;

        TInt lastIndex = 0;

        GetScrollerArea( firstIndexOnScreen, lastIndexOnScreen, lastIndex );

        // Determine scroll direction for optimal selection

        TInt maxPredict = KMaxPredictiveSelect;

        TBool scrollUp = iPreviousFirstScrollerIndex > firstIndexOnScreen;

        TBool scrollDown = iPreviousFirstScrollerIndex < firstIndexOnScreen;

        if ( scrollUp || scrollDown )

            {

            if ( scrollUp )

                {