/*

* 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 <vcxmyvideosdefs.h>

#include "vcxhgmyvideosmodel.h"

#include "vcxhgmyvideosmainview.h"

#include "vcxhgmyvideosvideolist.h"

#include "vcxhgmyvideosvideodataupdater.h"

#include "vcxhgmyvideosindicatorhelper.h"

const TInt KRefreshTimerInterval( 1000000 ); // 1 second

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

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

// CVcxHgMyVideosVideoDataUpdater::NewL()

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

//

CVcxHgMyVideosVideoDataUpdater* CVcxHgMyVideosVideoDataUpdater::NewL(

        CVcxHgMyVideosModel& aModel,

        CHgScroller& aScroller,

        CVcxHgMyVideosVideoList& aVideoArray )

    {

    CVcxHgMyVideosVideoDataUpdater* self = 

        CVcxHgMyVideosVideoDataUpdater::NewLC( aModel,

                                               aScroller,

                                               aVideoArray );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxHgMyVideosVideoDataUpdater::NewLC()

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

//

CVcxHgMyVideosVideoDataUpdater* CVcxHgMyVideosVideoDataUpdater::NewLC(

        CVcxHgMyVideosModel& aModel,

        CHgScroller& aScroller,

        CVcxHgMyVideosVideoList& aVideoArray )

    {

    CVcxHgMyVideosVideoDataUpdater* self = 

        new (ELeave) CVcxHgMyVideosVideoDataUpdater( aModel,

                                                     aScroller,

                                                     aVideoArray );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CVcxHgMyVideosVideoDataUpdater::CVcxHgMyVideosVideoDataUpdater()

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

//

CVcxHgMyVideosVideoDataUpdater::CVcxHgMyVideosVideoDataUpdater(

        CVcxHgMyVideosModel& aModel,

        CHgScroller& aScroller,

        CVcxHgMyVideosVideoList& aVideoArray )

  : CActive( EPriorityStandard ),

    iModel( aModel ),

    iScroller( aScroller ),

    iVideoArray( aVideoArray ),

    iPaused( EFalse )

    {

    CActiveScheduler::Add( this );

    }

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

// CVcxHgMyVideosVideoDataUpdater::ConstructL()

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

//

void CVcxHgMyVideosVideoDataUpdater::ConstructL()

    {

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

    }

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

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

    {

    }

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

// CVcxHgMyVideosVideoDataUpdater::SetPausedL()

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

//

void CVcxHgMyVideosVideoDataUpdater::SetPausedL( TBool aPaused )

    {

    iPaused = aPaused;

    if ( ! iPaused )

        {

        ContinueVideoDataFetchingL();

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::RequestDataL()

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

//

void CVcxHgMyVideosVideoDataUpdater::RequestDataL( TMPXItemId aMPXItemId )

    {

    AddItemToFetchArrayL( aMPXItemId );

    ContinueVideoDataFetchingL();

    }

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

// CVcxHgMyVideosVideoDataUpdater::ReleaseData()

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

//

void CVcxHgMyVideosVideoDataUpdater::ReleaseData( TMPXItemId aMPXItemId )

    {

    RemoveItem( IndexByMPXItemId( aMPXItemId ) );  

    }

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

// CVcxHgMyVideosVideoDataUpdater::RemoveItem()

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

//

void CVcxHgMyVideosVideoDataUpdater::RemoveItem( TInt aIndex )

    {

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

        {

        CancelActivities( aIndex );

        delete iFetchArray[aIndex];

        iFetchArray[aIndex] = NULL;

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

        {

            {

            }

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::CancelAndDeleteFetchArray()

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

//

void CVcxHgMyVideosVideoDataUpdater::CancelAndDeleteFetchArray()

    {    

        {

        }

    iFetchArray.ResetAndDestroy();

    }

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

// CVcxHgMyVideosVideoDataUpdater::ContinueVideoDataFetchingL()

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

//

void CVcxHgMyVideosVideoDataUpdater::ContinueVideoDataFetchingL()

    {

        {

            {

                {

                    {

                        {

                        }

                        {

                        }

                    }

                    {

                }

            }

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::UpdateVideoDataToUiL()

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

//

    {

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

        {       

        CHgItem& listItem = iScroller.ItemL( index );

            {

            listItem.SetIcon( thumbnail ); 

            }

        if ( drmUpdate )

            {

            TVcxHgMyVideosIndicatorHelper::TIndicatorDrmStatus drmStatus;

            CMPXMedia* media = iVideoArray.MPXMedia( index );

            if ( media )

                {

                TVcxHgMyVideosIndicatorHelper indicatorHelper;

                TInt indicator1( 0 );

                TInt indicator2( 0 );

                    {

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

            }

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::IndexByMPXItemId()

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

//

TInt CVcxHgMyVideosVideoDataUpdater::IndexByMPXItemId( TMPXItemId aMPXItemId )

    {   

        {

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

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// CVcxHgMyVideosVideoDataUpdater::SelectNextIndexL()

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

// 

    {   

    TInt firstIndexOnScreen = iScroller.FirstIndexOnScreen();

    if ( firstIndexOnScreen < 0 ) 

        {

        firstIndexOnScreen = 0;

        }

    TInt lastIndexOnScreen = firstIndexOnScreen + iScroller.ItemsOnScreen();

    if ( lastIndexOnScreen >= iScroller.ItemCount() )

        {

        lastIndexOnScreen = iScroller.ItemCount() - 1;

        }

    // If visible items not found, updater takes object from 0 index. 

    for ( TInt i = firstIndexOnScreen; i <= lastIndexOnScreen; i++ )

        {      

        TInt index( KErrNotFound );

        TMPXItemId mpxItemId;

        CGulIcon* icon( NULL );

        // Skip if list item already have a thumbnail.

        icon = iScroller.ItemL( i ).Icon();

        if ( !icon )

            {

            mpxItemId = iVideoArray.ArrayIndexToMpxItemIdL( i );

            index = IndexByMPXItemId( mpxItemId );

                {

                // Move selected index to first index of the fetch array. 

                }

            }

        }

    }

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

// CVcxHgMyVideosVideoDataUpdater::RefreshTimerCallBack()

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

//

TInt CVcxHgMyVideosVideoDataUpdater::RefreshTimerCallBack( TAny* aAny )

    {

    CVcxHgMyVideosVideoDataUpdater* self = static_cast<CVcxHgMyVideosVideoDataUpdater*>( aAny ); 

    self->iRefreshTimer->Cancel();

    if ( self->iListRefreshIsDelayed )

        {

        self->iListRefreshIsDelayed = EFalse;

        if ( !self->iPaused )

            {

            self->RefreshScreen();

            }

        }

    return KErrNone;

    }

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

// CVcxHgMyVideosVideoDataUpdater::RefreshScreen()

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

//

void CVcxHgMyVideosVideoDataUpdater::RefreshScreen()

    {

    IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # CVcxHgMyVideosVideoDataUpdater::RefreshScreen()" );

    iScroller.DrawDeferred();

    }

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

// CVcxHgMyVideosVideoDataUpdater::ListRefreshNeeded()

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

//

TBool CVcxHgMyVideosVideoDataUpdater::ListRefreshNeeded( TInt aIndex )

    {

    TBool modifiedIndexOnScreen( EFalse );

    TInt firstIndexOnScreen( iScroller.FirstIndexOnScreen() );

    if ( firstIndexOnScreen < 0 )

        {

        firstIndexOnScreen = 0;

        }

    TInt lastIndexOnScreen = firstIndexOnScreen + iScroller.ItemsOnScreen(); 

    if ( lastIndexOnScreen >= iScroller.ItemCount() )