/*

* 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:    HG VOD*

*/

#include <aknmessagequerydialog.h>

#include <StringLoader.h>

#include <vcxhgvodui.rsg>

#include <ganes/HgScroller.h>

#include <ganes/HgItem.h>

#include <ganes/HgDoubleGraphicList.h>

#include "vcxnsserviceproviderif.h"

#include "vcxnscategoryproviderif.h"

#include "vcxhgvodservicegrouplistimpl.h"

#include "vcxhgvodservicegrouplistmodelhandler.h"

#include "vcxhgvodmainview.h"

#include "vcxhgvodmainviewcontainer.h"

#include "vcxhgvodui.hrh"

#include "vcxhgvodutils.h"

#include "vcxnsuiengine.h"

#include "vcxnsservice.h"

#include "vcxnscategory.h"

#include "vcxhgvodthumbnailmanager.h"

TInt FindServiceGroupIndex( TUint32 aId, RPointerArray<CVcxNsService>* aArray )

    {

    TInt index( KErrNotFound );

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

        {

        if ( (*aArray)[i]->GetServiceId() == aId )

            {

            index = i;

            break;

            }

        }

    return index;

    }

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

// CVcxHgVodServiceListModelHandler::~CVcxHgVodServiceListModelHandler()

// Destructor

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

//

CVcxHgVodServiceGroupListModelHandler::~CVcxHgVodServiceGroupListModelHandler()

    {

    if ( iServiceProvider )

        {

        iServiceProvider->DeRegisterObserver( this );

        }

    delete iTnManager;

    }

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

// CVcxHgVodServiceListImpl::NewL()

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

//

CVcxHgVodServiceGroupListModelHandler* CVcxHgVodServiceGroupListModelHandler::NewL( 

    CVcxNsUiEngine& aDataProviderIf,

    CVcxHgVodMainView& aView, 

    CHgScroller& aScroller,

    CVcxHgVodServiceGroupListImpl& aServiceGroupListImpl )

    {

    CVcxHgVodServiceGroupListModelHandler* self = 

        CVcxHgVodServiceGroupListModelHandler::NewLC(  

                aDataProviderIf, 

                aView,

                aScroller,

                aServiceGroupListImpl );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxHgVodServiceGroupListModelHandler::NewLC()

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

//

CVcxHgVodServiceGroupListModelHandler* CVcxHgVodServiceGroupListModelHandler::NewLC(

    CVcxNsUiEngine& aDataProviderIf,

    CVcxHgVodMainView& aView, 

    CHgScroller& aScroller,

    CVcxHgVodServiceGroupListImpl& aServiceGroupListImpl )

    {

    CVcxHgVodServiceGroupListModelHandler* self = 

        new (ELeave) CVcxHgVodServiceGroupListModelHandler(  

                aDataProviderIf,

                aView,

                aScroller, 

                aServiceGroupListImpl );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CVcxHgVodServiceGroupListModelHandler::CVcxHgVodServiceGroupListModelHandler()

// Constructor

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

//

CVcxHgVodServiceGroupListModelHandler::CVcxHgVodServiceGroupListModelHandler( 

    CVcxNsUiEngine& aDataProviderIf, 

    CVcxHgVodMainView& aView, 

    CHgScroller& aScroller,

    CVcxHgVodServiceGroupListImpl& aServiceGroupListImpl )

    : iDataProviderIf ( aDataProviderIf ),

      iScroller ( aScroller ),

      iView ( aView ),

      iListImpl ( aServiceGroupListImpl )

    {

    }

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

// CVcxHgVodServiceGroupListModelHandler::ConstructL()

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

//

void CVcxHgVodServiceGroupListModelHandler::ConstructL()

    {

    iServiceProvider = iDataProviderIf.GetServiceProviderL();

    iTnManager = CVcxHgVodThumbnailManager::NewL( iView.EikonEnv().FsSession() );

    }

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

// 

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

// 

void CVcxHgVodServiceGroupListModelHandler::ServiceAdded( TInt /*aIndex*/ )

    {

    }

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

// 

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

// 

void CVcxHgVodServiceGroupListModelHandler::ServiceUpdated( TInt aIndex )

    {

    TRAP_IGNORE( UpdateListItemL( aIndex ) );

    }

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

// Refresh view, update all services.

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

// 

void CVcxHgVodServiceGroupListModelHandler::RefreshView()

    {

    if ( iDataProviderIf.VcAppState() == EStateCustomView )

        {

        TRAPD( err, iGroupServices = &(iServiceProvider->GetActiveGroupListL()) );

        if ( err == KErrNone )

            {

            TInt highlight = iScroller.SelectedIndex();

            TRAP_IGNORE( RefreshViewL() );

            if ( iScroller.ItemCount() > 0 )

                {

                if ( highlight < 0 )

                    {

                    highlight = 0;

                    }

                else if ( highlight >= iScroller.ItemCount() )

                    {

                    highlight = iScroller.ItemCount() - 1;

                    }

                iScroller.SetSelectedIndex( highlight );

                }

            }

        }

    }

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

// Handle service removal (no implementation)

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

// 

void CVcxHgVodServiceGroupListModelHandler::ServiceRemoved( 

    TInt /*aIndex*/, 

    RPointerArray<CVcxNsService>& /*aUpdatedServiceList*/ )

    {

    }

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

// Application state change initialized by data provider.

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

// 

void CVcxHgVodServiceGroupListModelHandler::HandleAppStateChangedL()

    {

    iView.ChangeListViewL();

    }

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

// Open defined browser link

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

// 

void CVcxHgVodServiceGroupListModelHandler::OpenBrowserLinkL( const TDesC& aUri )

    {

    iListImpl.OpenEmbeddedBrowserL( aUri );

    }

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

// open streaming link

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

// 

void CVcxHgVodServiceGroupListModelHandler::OpenStreamingLinkL( const TDesC& aUri )

    {

    iView.PlayStreamL( aUri );

    }

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

// Activate model

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

// 

void CVcxHgVodServiceGroupListModelHandler::DoActivateModelL( )

    {

    iServiceProvider->RegisterObserver( this );

    iGroupServices = &(iServiceProvider->GetActiveGroupListL());

    iScroller.EnableScrollBufferL( *this, KScrollerBufferSize, KScrollerBufferTreshold );

    iScroller.Reset();

    RefreshViewL();

    iScroller.SetSelectedIndex( iHighlight );

    iScroller.ControlEnv()->WsSession().ClearAllRedrawStores();

    iScroller.MakeVisible( ETrue );

    iScroller.DrawDeferred();

    }

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

// Deactivate model

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

// 

void CVcxHgVodServiceGroupListModelHandler::DoDeActivateModel( )

    {

    if ( iServiceProvider )

        {

        iServiceProvider->DeRegisterObserver( this );

        }

    iTnManager->Reset();

    iHighlight = iScroller.SelectedIndex();

    iScroller.DisableScrollBuffer();

    iScroller.MakeVisible( EFalse );

    }

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

// Get highlight index

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

// 

TInt CVcxHgVodServiceGroupListModelHandler::GetSelected() 

    {

    return iScroller.SelectedIndex();

    }

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

// CVcxHgVodServiceGroupListModelHandler::IsEmptyModel

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

//

TBool CVcxHgVodServiceGroupListModelHandler::IsEmptyModel()

    {

    return iScroller.ItemCount() <= 0;

    }

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

// CVcxHgVodServiceGroupListModelHandler::GenerateInfoTextLC

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

//

HBufC* CVcxHgVodServiceGroupListModelHandler::GenerateInfoTextLC( 

    CVcxNsService& aGroupService )

    {

    if ( aGroupService.Type() == CVcxNsService::EVcxNsGroupedSearch )

        {

        MVcxNsCategoryProviderIf* categoryProvider = 

            iDataProviderIf.GetCategoryProviderL();

        CVcxNsCategory* category = NULL;

        if ( categoryProvider )

            {

            category = categoryProvider->GetCategoryDataL( 

                           aGroupService.GetServiceId(), 

                           KIptvRssSearchCategoryId );

            }

        TInt count = 0;

        if ( category ) 

            {

            count = category->GetVideoCount();

            }

        if ( count == 1 )

            {

            return CVcxHgVodUtils::LoadStringFromResourceLC( 

                    R_VCXHG_SEARCH_VIDEOS_FOUND_ONE );

            }

        else if ( count > 1 ) 

            {

            return CVcxHgVodUtils::LoadStringFromResourceLC( 

                    R_VCXHG_SEARCH_VIDEOS_FOUND, count );            

            }

        }

    return aGroupService.GetDesc().AllocLC();

    }

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

// 

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

// 

TInt CVcxHgVodServiceGroupListModelHandler::ItemCount()

    {

    return iScroller.ItemCount();

    }

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

// 

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

// 

void CVcxHgVodServiceGroupListModelHandler::MvtoThumbnailReady( 

    CGulIcon* aIcon,

    TInt64 aClientId )

    {

    // error ignored, as there is no error handling that can be done if this leaves

    TRAP_IGNORE( DoThumbnailReadyL( aIcon, aClientId ) );

    }

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

// 

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

// 

void CVcxHgVodServiceGroupListModelHandler::RefreshViewL()

    {

    iScroller.Reset();

    if ( iGroupServices && iGroupServices->Count() > 0 )

        {

        iScroller.ResizeL( iGroupServices->Count() );

        }

    else

        {

        CVcxNsService* service = iServiceProvider->GetActiveServiceData();

        if ( service && 

             service->Type() == CVcxNsService::EVcxNsMainGroup && 

             service->GetUpdateStatus() == CVcxNsService::EUpdateFailed )

            {

            //Does this need empty list text? (not specified in ui spec)

            //There's no text available, so if update failed, return 

            //to video feeds view. 

            iView.HandleCommandL( EAknSoftkeyBack );

            }

        iListImpl.CheckSoftkeysL();

        }

    iScroller.DrawDeferred();

    }

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

// 

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

// 

void CVcxHgVodServiceGroupListModelHandler::UpdateListItemL( TInt aIndex ) 

    {

    if ( iDataProviderIf.VcAppState() == EStateCustomView &&

         aIndex >= 0 && aIndex < iScroller.ItemCount() && 

         iGroupServices && iGroupServices->Count() > aIndex )    

        {

        CHgItem& item = iScroller.ItemL( aIndex ); 

        CVcxNsService& service = *(*iGroupServices)[aIndex];

        item.SetTitleL( service.GetName() );

        HBufC* info = GenerateInfoTextLC( service );

        item.SetTextL( *info );

        CleanupStack::PopAndDestroy( info );

        item.SetIcon( NULL );

        const TDesC& iconPath = service.GetIconPath();

        if ( iconPath.Length() > 0 )

            {

            iTnManager->AddThumbnailRequestL( *this,

                                              service.GetIconPath(), 

                                              CHgDoubleGraphicList::PreferredImageSize(), 

                                              service.GetServiceId() );

            }

        iScroller.RefreshScreen( aIndex );

        }

    iListImpl.SetMskL( R_VCXHG_VOD_MSK_BUTTON_OPEN );

    }

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

// 

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

// 

void CVcxHgVodServiceGroupListModelHandler::DoThumbnailReadyL( 

    CGulIcon* aIcon, 

    TInt64 aClientId )

    {

    CleanupStack::PushL( aIcon );

    TInt index = FindServiceGroupIndex( (TUint32)aClientId, iGroupServices );

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

        {

        iScroller.ItemL( index ).SetIcon( aIcon );

        iScroller.RefreshScreen( index );

        CleanupStack::Pop( aIcon );

        }

    else

        {

        // For some reason the scroller list was update after image conversion

        // started, and the icon is no longer needed.

        CleanupStack::PopAndDestroy( aIcon );

        }

    }

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

//  

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

//

void CVcxHgVodServiceGroupListModelHandler::Request( TInt aBufferStart, 

    TInt aBufferEnd, THgScrollDirection /*aDirection*/ )

    {

    for ( TInt i = aBufferStart; i <= aBufferEnd; i++ )

        {

        TRAP_IGNORE( UpdateListItemL( i ) );

        }

    }

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

//  

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

//

void CVcxHgVodServiceGroupListModelHandler::Release( TInt /*aBufferStart*/, 

    TInt /*aBufferEnd*/ )

    {

    // No implementation required.

    }