/*

* 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 category list implementation*

*/

#include <eikenv.h>

#include <eikmenup.h>

#include <aknViewAppUi.h>

#include <StringLoader.h>

#include <SendUiConsts.h>

#include <vcxhgvodui.rsg>

#include <aknnotewrappers.h>

#include <ganes/HgScroller.h>

#include <csxhelp/iptv.hlp.hrh>

#include "vcxnsuiengine.h"

#include "vcxnscategory.h"

#include "vcxnscategoryproviderif.h"

#include "vcxnscontentproviderif.h"

#include "vcxnsservice.h"

#include "vcxnsserviceproviderif.h"

#include "vcxhgvodcontentlistimpl.h"

#include "vcxhgvodlistimplbase.h"

#include "vcxhgvodcontentlistimpl.h"

#include "vcxhgvodcontentlistmodelhandler.h"

#include "vcxhgvodmainview.h"

#include "vcxhgvodmainviewcontainer.h"

#include "vcxhgvodui.hrh"

#include "vcxhgvodutils.h"

#include "vcxhgvodsearchimpl.h"

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

// CVcxHgVodContentListImpl::~CVcxHgVodContentListImpl()

// Destructor

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

//

CVcxHgVodContentListImpl::~CVcxHgVodContentListImpl()

    {

    //always set model null to widget before destroying it

    delete iModelHandler;

    }

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

// CVcxHgVodContentListImpl::NewL()

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

//

CVcxHgVodContentListImpl* CVcxHgVodContentListImpl::NewL(

    CHgScroller& aScroller, 

    CVcxNsUiEngine& aDataProviderIf,

    CVcxHgVodMainView& aView )

    {

    CVcxHgVodContentListImpl* self = 

        CVcxHgVodContentListImpl::NewLC( 

                aScroller, aDataProviderIf, aView );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxHgVodContentListImpl::NewLC()

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

//

CVcxHgVodContentListImpl* CVcxHgVodContentListImpl::NewLC(

    CHgScroller& aScroller, 

    CVcxNsUiEngine& aDataProviderIf, 

    CVcxHgVodMainView& aView )

    {

    CVcxHgVodContentListImpl* self = 

        new (ELeave) CVcxHgVodContentListImpl( 

            aScroller, aDataProviderIf, aView );

    CleanupStack::PushL( self );

    self->ConstructL( aDataProviderIf, aView );

    return self;

    }

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

// 

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

void CVcxHgVodContentListImpl::DoActivateL( )

    {

    if ( iSearchImpl )

        {

        iSearchImpl->RegisterObserver();

        }

    SetMenuResourceId( R_VCXHG_VOD_CONTENTVIEW_MENUBAR );

    SetEmptyListTextL( R_VCXHG_VOD_UPDATING_ITEMS );

    //Set default context menu

    iView.MenuBar()->SetContextMenuTitleResourceId( 

        R_VCXHG_VOD_MSK_CONTENT_CONTEXT_MENUBAR );

    SetMskL( R_VCXHG_VOD_MSK_BUTTON_DO_NOTHING );

    iScroller.SetSelectionObserver( *this );

    iView.AppUi()->AddToStackL( &iScroller );

    iScroller.SetFocus( ETrue );

    iModelHandler->DoActivateModelL();

    UpdateTitlePaneL();

    CVcxNsService* currentService =

        iModel.GetServiceProviderL()->GetActiveServiceData();

    TUint32 activeCategory = iModel.ActiveCategory();

    if ( ( activeCategory == KVcxNsSearchCategoryId )

            && ( iScroller.ItemCount() == 0 ) )

        {

        // Set empty list text "no videos found" when opened search

        // category and it's empty. 

        SetEmptyListTextL( R_VCXHG_NO_VIDEOS_FOUND );

        }

    else if ( iScroller.ItemCount() == 0 &&

              currentService->GetUpdateTime() != 0 )

        {

        // Set empty list text "no videos" only if content list is empty

        // and service has been updated successfully at least once.

        SetEmptyListTextL( R_VCXHG_VOD_NO_DATA );

        }

    if( currentService &&

        currentService->GetUpdateStatus() == CVcxNsService::EUpdateOngoing )

        {

        ShowInformationPopupL( ETrue, 0, 0 );

        }

    }    

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

//  

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

void CVcxHgVodContentListImpl::DoDeactivate( )

    {

    //Make sure that MSK is updated when returning to view

    iCurrentMskResource = 0;

    iModelHandler->DoDeActivateModel();

    iView.AppUi()->RemoveFromStack( &iScroller );

    iScroller.SetFocus( EFalse );

    TRAP_IGNORE( ShowInformationPopupL( EFalse, 0, 0 ) );

    if ( iSearchImpl )

        {

        iSearchImpl->DeRegisterObserver();

        }

    }

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

// CVcxHgVodContentListImpl::CVcxHgVodContentListImpl()

// Constructor

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

//

CVcxHgVodContentListImpl::CVcxHgVodContentListImpl( 

    CHgScroller& aScroller,

    CVcxNsUiEngine& aDataProviderIf,

    CVcxHgVodMainView& aView )

    : CVcxHgVodListImplBase( aView, aDataProviderIf, aScroller ),

      iEmailAccountEnabled ( EFalse )

    {

    // None

    }

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

// CVcxHgVodContentListImpl::ConstructL()

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

//

void CVcxHgVodContentListImpl::ConstructL( 

    CVcxNsUiEngine& aDataProviderIf,

    CVcxHgVodMainView& aView )

    {

    iModelHandler = 

        CVcxHgVodContentListModelHandler::NewL( 

                aDataProviderIf, aView, iScroller, *this );

    CVcxHgVodListImplBase::InitSearchImplL();

    iEmailAccountEnabled = CVcxHgVodUtils::IsDefaultSmtpAccountDefinedL();

    }

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

// CVcxHgVodContentListImpl::HandleCommandL

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

//

void CVcxHgVodContentListImpl::HandleCommandL( TInt aCommand )

    {

    TInt selected = iScroller.SelectedIndex();

    MVcxNsContentProviderIf* contentProvider = 

        iModelHandler->ContentProvider();

    switch ( aCommand )

        {

        case EVcxHgVodContentStartDownloadCmd:

            {

            if ( selected >= 0 ) 

                {

                contentProvider->StartDownloadL( selected );

                }

            }

            break;

        case EVcxHgVodContentResumeDownloadCmd:

            {

            if ( selected >= 0 )

                {

                contentProvider->ResumeDownloadL( selected );

                }

            }

            break;        

        case EVcxHgVodContentCancelDownloadCmd:

            {

            if ( selected >= 0 )

                {

                contentProvider->CancelDownloadL( selected );

                HBufC* text = StringLoader::LoadLC( R_VCXHGVOD_DOWNLOAD_CANCELED );

                CAknConfirmationNote* note = new (ELeave) CAknConfirmationNote( ETrue );

                note->ExecuteLD( *text );

                CleanupStack::PopAndDestroy( text );    

                }

            }

            break;

        case EVcxHgVodContentPlayCmd:

            {

            StartPlaybackL();

            }

            break;

        case EVcxHgVodContentNewSearchCmd:

            {

            if ( iSearchImpl )

                {

                iSearchImpl->StartSearchL( EFalse );

                }

            }

            break;

        case EVcxHgVodContentOpenLinkCmd:

            {

            if ( selected >= 0 )

                {

                OpenBrowserLinkL( selected );

                }

            }

            break;

        case EVcxHgVodContentDetailsCmd:

            {

            if ( selected >= 0 )

                {

                iModelHandler->ShowVideoDetailsL( selected );

                }

            }

            break;

        case EVcxHgVodContentSendCmd:

            {

            if ( !iEmailAccountEnabled )

                {

                HandleCommandL( EVcxHgVodContentSendViaMsgCmd );

                }

            else

                {

                // Switching to context sensitive menu.

                iView.MenuBar()->SetContextMenuTitleResourceId( R_VCXHG_VOD_SEND_CONTEXT_MENUBAR );

                iView.MenuBar()->TryDisplayContextMenuBarL();

                iView.MenuBar()->SetContextMenuTitleResourceId( R_VCXHG_VOD_MSK_CONTENT_CONTEXT_MENUBAR );

                // Switching back to normal options menu.

                iView.MenuBar()->SetMenuType( CEikMenuBar::EMenuOptions );

                iView.MenuBar()->SetMenuTitleResourceId( R_VCXHG_VOD_CONTENTVIEW_MENUBAR );

                }

            }

            break;

        case EVcxHgVodContentSendViaMsgCmd:

            {

            ShareLinkL( KSenduiMtmSmsUid, selected );

            }

            break;

        case EVcxHgVodContentSendViaEmailCmd:

            {

            ShareLinkL( KSenduiMtmSmtpUid, selected  );

            }

            break;

        case EVcxHgVodContentScheduleDownloadsCmd:

            {

            iView.OpenScheduleSettingsL();

            }

            break;

        default:

            break;

        }

    }

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

// Activate usable menu items before showing menu

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

//

void CVcxHgVodContentListImpl::ActivateMenuPaneItemsL( 

    CEikMenuPane* aMenuPane,

    TInt aResourceId )

    {

    if ( aMenuPane )

        {

        if ( aResourceId == R_VCXHG_VOD_CONTENTVIEW_SHARE_LINK_SUBMENU )

            {

            if ( !iEmailAccountEnabled )

                {

                aMenuPane->SetItemDimmed( EVcxHgVodContentSendViaEmailCmd, ETrue );

                }

            }

        if  ( aResourceId == R_VCXHG_VOD_CONTENTVIEW_MENU 

                || aResourceId == R_VCXHG_VOD_CONTENTVIEW_CONTEXT_MENU )

            {

            TBool showPlay( EFalse );

            TBool showDownload( EFalse );

            TBool showResume ( EFalse );

            TBool showCancel( EFalse );

            TBool showOpenLink ( EFalse );

            TBool showDetails( EFalse );

            RPointerArray<CVcxNsContent>& contents = 

                iModelHandler->ContentProvider()->GetContentsL();

            TInt highlight = iScroller.SelectedIndex();

            CVcxNsContent::TVcxContentDlStatus dlStatus( CVcxNsContent::EVcxContentDlStateNotFound );

            TUint32 dltypes( 0 );

            if( highlight >=0 && highlight < contents.Count() )

                {

                dlStatus = ( contents[highlight] )->GetDlStatus();

                dltypes = ( contents[highlight] )->GetContentTypes();

                if ( ( contents[highlight] )->GetBrowserUrl().Length() > 0 )

                    {

                    showOpenLink = ETrue; 

                    }

                if ( !iModelHandler->IsEmptyModel() 

                        && iModelHandler->ContentProvider()->HasVideoDetailsL( highlight ) )

                    {

                    showDetails = ETrue;

                    }

                if( dltypes & CVcxNsContent::EVcxContentTypeVideo )

                    {

                    switch ( dlStatus )

                        {

                        case CVcxNsContent::EVcxContentDlStateNone:

                        case CVcxNsContent::EVcxContentDlStateNotFound:

                            {

                            showDownload = ETrue; 

                            }

                            break;

                        case CVcxNsContent::EVcxContentDlStateDownloading:

                            {

                            showCancel = ETrue; 

                            showPlay = ETrue;

                            }

                            break;

                        case CVcxNsContent::EVcxContentDlStateFailed:

                        case CVcxNsContent::EVcxContentDlStatePaused:

                            {

                            showPlay = ETrue;

                            showResume = ETrue;

                            showCancel = ETrue;

                            }

                            break;

                        case CVcxNsContent::EVcxContentDlStateDownloaded:

                            {

                            showPlay = ETrue;

                            }

                            break;

                        case CVcxNsContent::EVcxContentDlStateCanceling:

                            break;

                        default:

                            break;

                        }

                    }

                // Play cmd is always visible, if there's stream.

                if( dltypes & CVcxNsContent::EVcxContentTypeStream )

                    {

                    showPlay = ETrue;

                    }

                }

            //For both menus:

            aMenuPane->SetItemDimmed( EVcxHgVodContentStartDownloadCmd, !showDownload );

            aMenuPane->SetItemDimmed( EVcxHgVodContentPlayCmd, !showPlay );

            aMenuPane->SetItemDimmed( EVcxHgVodContentResumeDownloadCmd, !showResume );

            aMenuPane->SetItemDimmed( EVcxHgVodContentCancelDownloadCmd, !showCancel );

            if  ( aResourceId == R_VCXHG_VOD_CONTENTVIEW_MENU ) 

                {

                aMenuPane->SetItemDimmed( EVcxHgVodContentDetailsCmd, !showDetails );

                aMenuPane->SetItemDimmed( EVcxHgVodContentOpenLinkCmd, !showOpenLink );

                if ( iModel.ActiveCategory() == KVcxNsSearchCategoryId )

                    {

                    aMenuPane->SetItemDimmed( EVcxHgVodContentNewSearchCmd, EFalse );

                    }

                else

                    {

                    aMenuPane->SetItemDimmed( EVcxHgVodContentNewSearchCmd, ETrue );

                    }

                if ( iModelHandler->IsEmptyModel() )

                    {

                    aMenuPane->SetItemDimmed( EVcxHgVodContentSendCmd, ETrue );

                    }

                }

            }

        }

    }

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

// CVcxHgVodContentListImpl::StartPlaybackL

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

//

void CVcxHgVodContentListImpl::StartPlaybackL()

    {

    RPointerArray<CVcxNsContent>& contents = iModel.GetContentProviderL()->GetContentsL();

    TInt highlight = iScroller.SelectedIndex();

    if( highlight >= 0 && contents.Count() > highlight )

        {

        iView.PlayInternalVideoL( contents[highlight] );

        }

    }

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

//  

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

//

void CVcxHgVodContentListImpl::HandleSelectL( TInt /*aIndex*/ )

    {

    CheckMskL();

    }

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

// CVcxHgVodContentListImpl::AakashItemSelectedL

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

//

void CVcxHgVodContentListImpl::HandleOpenL( TInt /*aIndex*/ )

    {

    //This check must be done because ETypeSelect event is received

    //from antriksh even if context menu item defined as msk button.

    if ( iCurrentMskResource == R_VCXHG_VOD_MSK_BUTTON_CTXTMENU

          && ! iView.IsTouchSupported() )

        {

        return;

        }

    HandleSelectionL();

    }

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

// CVcxHgVodContentListImpl::MediaKeyEventL

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

//

void CVcxHgVodContentListImpl::MediaKeyEventL(

    TRemConCoreApiOperationId aOperationId, 

    TRemConCoreApiButtonAction /*aButtonAct*/ )

    {

    if ( iModel.VcAppState() == EStateContentView &&

         ( aOperationId == ERemConCoreApiPause ||

           aOperationId == ERemConCoreApiPlay ||

           aOperationId == ERemConCoreApiPausePlayFunction ) )

        {

        HandleCommandL( EVcxHgVodContentPlayCmd );

        }

    }

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

// CVcxHgVodContentListImpl::UpdateTitlePaneL

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

//

void CVcxHgVodContentListImpl::UpdateTitlePaneL()

    {

    CVcxNsCategory* currentCategory =

        iModel.GetCategoryProviderL()->GetActiveCategoryDataL();

    if ( currentCategory )

        {

        if ( currentCategory->GetCategoryId() == KVcxNsSearchCategoryId )

            {

            HBufC* searchTitle = StringLoader::LoadLC( R_VCXHG_TITLE_VIDEO_SEARCH );

            SetTitlePaneTextL( *searchTitle );

            CleanupStack::PopAndDestroy( searchTitle );

            }

        else

            {

            if( currentCategory->GetName().Length() > 0 )

                {

                SetTitlePaneTextL( currentCategory->GetName());

                }

            else

                {

                SetTitlePaneTextFromResourceL( R_VCXHG_CATEGORIES_VIDEO_LIST );

                }

            }

        }

    else

        {

        CVcxNsService* currentService = 

            iModel.GetServiceProviderL()->GetActiveServiceData();

        if ( currentService )

            {

            SetTitlePaneTextL( currentService->GetName());

            }

        }

    }

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