/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:    Implementation of FULL-SCREEN view

*

*/

// Avkon and System Headers 

#include <eikbtgpc.h>                           // CEikButtonGroupContainer

#include <aknViewAppUi.h>

#include <data_caging_path_literals.hrh>        // for KDC_APP_RESOURCE_DIR

#include <glxcollectionpluginimageviewer.hrh>

#include <StringLoader.h>                       // String Loader

#include <AknIconUtils.h>

#include <e32math.h>

//For animation Effects

#include <akntranseffect.h>

#include <akntransitionutils.h>

#include <alf/alflayout.h>

// Alf Headers

#include <alf/ialfwidgetfactory.h>              // widget factory

#include <alf/alfwidgetcontrol.h>               // To get CAlfControl from CAlfWidgetControl

#include <alf/ialfviewwidget.h>                 // View Widget

#include <alf/alfwidgetenvextension.h>          // Widget Env Extensions to create view widget

#include <alf/alfutil.h>                        // AlfUtil

// Antariksh Headers

#include <mul/mulevent.h>

#include <mul/imulcoverflowwidget.h>            // Coverflow widget

#include <mul/imulsliderwidget.h>               // For Slider Widget

#include <mpxcollectionpath.h>

#include <gesturehelper.h>

#include <coeutils.h>

using namespace GestureHelper;

#include <glxhdmicontroller.h>

// Photos Headers

#include <glxlog.h>                             // CGlxLogger

#include <glxtracer.h>                          // For Log

#include <glxmedialistmulmodelprovider.h>       // For MulModelProvider

#include <glxcommandhandlers.hrh>               // For EGlxCmdFullScreenBack               

#include <glxfullscreenviewdata.rsg>            // FS View Resource

#include <glxthumbnailattributeinfo.h>          // KGlxMediaIdThumbnail

#include <glxactivemedialistregistry.h>         // For medialist registry

#include <glxerrormanager.h>

#include <glxzoomcontrol.h>

#include <glxuiutilities.rsg>

#include <glxgeneraluiutilities.h>

#include <glxtexturemanager.h>

#include <glxicons.mbg>

#include <glxsetappstate.h>

#include <glxdrmutility.h>

#include <glxscreenfurniture.h>

#include "glxfullscreenviewimp.h"

#include <glxnavigationalstate.h>

#include <glxmedia.h>

#include <glxnavigationalstate.h>

#include <mpxcollectionpath.h>

#include <glxcollectionpluginimageviewer.hrh>

#include <glxuistd.h>

#include "glxfullscreenbusyicon.h"

using namespace Alf;

const TInt KGlxScreenTimeout =10000000;

const TInt KCoverflowDataWindowSize = 1;

const TInt KGlxMaxSmallImageZoomLevel =150;

const TInt KGlxMaxBigImageZoomLevel   =100;

const TInt KGlxMinSmallImageZoomLevel =100;

const TInt KGlxNeutralPinchPosition   =100;

const TInt KGlxSliderTickValue        =5;

const TInt KGlxRealTruncationPadding  =0.5;

/**

 * Start Delay for the periodic timer, in microseconds

 */

const TInt KPeriodicStartDelay = 250000; 

/**

 * Interval delay for the periodic timer, in microseconds

 */

const TInt KPeriodicIntervalDelay = 500000; 

/** 

 * Fullscreen texture offset 

 */ 

const TInt KTextureOffset = 2; 

// This constant is used to calculate the index of the item 

// for which texture has to removed.

const TInt KFullScreenIterator = KTextureOffset + 1; 

// This constant is used to calculate the maximum number of fullscreen textures 

// needs to be updated during foreground event.

const TInt KFullScreenTextureOffset = KFullScreenIterator + KTextureOffset;

const TInt KGlxDecodingThreshold = 3000000; // pixels

_LIT( KTfxResourceActivateFullScreen, "z:\\resource\\effects\\photos_fullscreen_open.fxml" );

_LIT( KTfxResourceNoEffect, "");

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

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CGlxFullScreenViewImp::CGlxFullScreenViewImp(

		const TFullScreenViewResourceIds& aResourceIds, TInt aViewUID) :

	iResourceIds(aResourceIds), iViewUid(aViewUID)

	{

	TRACER("CGlxFullScreenViewImp::CGlxFullScreenViewImp");

	}

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

// Two-phased constructor.

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

//

CGlxFullScreenViewImp* CGlxFullScreenViewImp::NewL(

		MGlxMediaListFactory* aMediaListFactory,

		const TFullScreenViewResourceIds& aResourceIds, 

		TInt aViewUID,

		const TDesC& aTitle)

	{

	TRACER("CGlxFullScreenViewImp::NewL");

	CGlxFullScreenViewImp* self = CGlxFullScreenViewImp::NewLC (

			aMediaListFactory, aResourceIds, aViewUID, aTitle);

	CleanupStack::Pop (self);

	return self;

	}

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

// Two-phased constructor.

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

//

CGlxFullScreenViewImp* CGlxFullScreenViewImp::NewLC(

		MGlxMediaListFactory* aMediaListFactory,

		const TFullScreenViewResourceIds& aResourceIds, TInt aViewUID,

		const TDesC& aTitle)

	{

	TRACER("CGlxFullScreenViewImp::NewLC");

	CGlxFullScreenViewImp* self =new (ELeave) CGlxFullScreenViewImp(aResourceIds, aViewUID);

	CleanupStack::PushL (self);

	self->ConstructL (aMediaListFactory, aTitle);

	return self;

	}

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

//  ConstructL.

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

//

void  CGlxFullScreenViewImp::ConstructL(

		MGlxMediaListFactory* aMediaListFactory, const TDesC& aTitle)

	{

	TRACER("CGlxFullScreenViewImp::ConstructL");

	BaseConstructL (iResourceIds.iViewId);

	ViewBaseConstructL();

	MLViewBaseConstructL (aMediaListFactory, aTitle , EFalse);

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

	//Register the view to recieve toolbar events. ViewBase handles the events

	SetToolbarObserver(this);

	iImgViewerMode = EFalse;

    //Disable the toolbar always while entering fullscreen

	EnableFSToolbar(EFalse);

    ShowToolbarOnViewActivation(EFalse);

	//Get the ScreenFurniture instance

	iScreenFurniture = iUiUtility->ScreenFurniture();

    //Get the env from the uiutilities

	iEnv = iUiUtility->Env ();

	iZoomButtonGroup = CEikButtonGroupContainer::NewL(

	        CEikButtonGroupContainer::ECba,  // type

	        CEikButtonGroupContainer::EHorizontal,  // orientation

	        this,  // command observer

	        R_GLX_FULLSCREEN_SOFTKEYS_ZOOM ); 

	iZoomButtonGroup->MakeVisible( EFalse );

	//create the drmutility instance

	iDrmUtility = CGlxDRMUtility::InstanceL();

   // Get object that stores the active media list registry

    iActiveMediaListRegistry = CGlxActiveMediaListRegistry::InstanceL();

    iIsDialogLaunched = EFalse;

    iIsMMCRemoved = EFalse;

	iMMCNotifier = CGlxMMCNotifier::NewL(*this);

	if(!iPeriodic)

		{

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

		}

	iGlxTvOut = CGlxTv::NewL(*this);

	iNaviState = CGlxNavigationalState::InstanceL();

    }

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

// ~CGlxFullScreenViewImp()

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

//

CGlxFullScreenViewImp::~CGlxFullScreenViewImp()

    {

    TRACER("CGlxFullScreenViewImp::~CGlxFullScreenViewImp");

    if(iAlfEffectObs)

        {

        delete iAlfEffectObs;

        }

    if(iMMCNotifier)

        {

        delete iMMCNotifier;

        iMMCNotifier = NULL;

        }

    if (iUri)

        {

        delete iUri;

        }

    if(iMediaListMulModelProvider)

        {

        delete iMediaListMulModelProvider;

        }

    if(iTimer)

        {

        if(iTimer->IsActive())

            {

            iTimer->Cancel();

            }

        delete iTimer;

        }

	if(iZoomButtonGroup)

        {

        AppUi()->RemoveFromStack( iZoomButtonGroup );

        delete iZoomButtonGroup;

        }

	if(iGlxTvOut)

        {

        delete iGlxTvOut;

        }

    if(iActiveMediaListRegistry)

        {

        iActiveMediaListRegistry->Close();

	    }

    if( iDrmUtility )

		{

		iDrmUtility->Close();

		}

    if (iPeriodic)

 		{

 		iPeriodic->Cancel();

 		delete iPeriodic;

 		}

    if (iNaviState)

        {

        iNaviState->Close();

        }    

	}

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

// From CGlxViewBase

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

//

TUid CGlxFullScreenViewImp::Id() const

    {

    TRACER("CGlxFullScreenViewImp::Id");

    return TUid::Uid(iViewUid);

	}

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

// Destroys a coverflow widget

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

//

void CGlxFullScreenViewImp::DestroyWidgets()

    {

    TRACER("CGlxFullScreenViewImp::DestroyCoverflowWidget");

    if (iCoverFlowWidget)

        {

        iCoverFlowWidget->RemoveEventHandler(*this);

        }

    // Destror Slider widget

    DestroySliderWidget();

    delete iMediaListMulModelProvider;

    iMediaListMulModelProvider = NULL;

    IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(*iEnv); 

    // Destroying this widget calls destructor of single line meta pane

    widgetFactory.destroyWidget(iViewWidget);

    iCoverFlowWidget = NULL;

    iViewWidget = NULL;

    }

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

// Destroys a Slider widget

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

//

void CGlxFullScreenViewImp::DestroySliderWidget()

    {

    TRACER("CGlxFullScreenViewImp::DestroySliderWidget");

    if(iSliderWidget)

        {

        iSliderWidget->RemoveEventHandler(*this);

        }

    iSliderWidget = NULL;

    iSliderModel = NULL;

    }

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

// From CAknView

// Handles a view activation.

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

//

void CGlxFullScreenViewImp::DoMLViewActivateL(

		const TVwsViewId & /* aPrevViewId */, TUid /* aCustomMessageId */,

		const TDesC8 & /* aCustomMessage */)

	{

    TRACER("CGlxFullScreenViewImp::DoMLViewActivateL");

    // hide the toolbar

    EnableFSToolbar(EFalse);

    if (iMediaList->Count() == 0)

        {

        GLX_LOG_INFO("CGlxFullScreenViewImp::DoMLViewActivateL() - No items!");	

		// While in slideshow from fullscreen view,

        // 1) Connect USB in mass storage mode or 

        // 2) Delete items through file manager 

        // shall result in activating fullscreen view with no items; so, goto grid view.

        iNaviState->ActivatePreviousViewL();

        }

    else

        {

        //fix for ESLM-7YYDXC: When in FullScreen View, view mode must be 'EView'

        //While coming back from SlideShow to FullScreen view, need to set view mode.

        if (iMediaList->Count() && iNaviState->ViewingMode()

                != NGlxNavigationalState::EView)

            {

            iNaviState->SetToViewMode();

            }

        }

    CMPXCollectionPath* collPath = iNaviState->StateLC();

    if (collPath->Id() == TMPXItemId(

            KGlxCollectionPluginImageViewerImplementationUid))

        {

        iImgViewerMode = ETrue;

        CreateImageViewerInstanceL();

        }

    CleanupStack::PopAndDestroy(collPath);

    iScrnSize = iUiUtility->DisplaySize();

    iGridIconSize = iUiUtility->GetGridIconSize();

    iHdmiWidth = (iScrnSize.iWidth > iScrnSize.iHeight ?iScrnSize.iWidth :iScrnSize.iHeight);

    iHdmiHeight = (iScrnSize.iWidth < iScrnSize.iHeight ?iScrnSize.iWidth :iScrnSize.iHeight);

    //Create hdmicontroller when it is only launched from fullscreen.  

    //From filemanager show only clone mode.

    iHdmiController = CGlxHdmiController::NewL(*this); 

    if( !iImgViewerMode )    

        {

        SetItemToHDMIL();

        }

    iScreenFurniture->SetActiveView(iViewUid);

    //set the ui state to off,when the Fullscreen launches

    SetUiState(EUiOff);

   	GlxSetAppState::SetState(EGlxInFullScreenView);

    // create the coverflow

    CreateCoverflowWidgetL();

    CreateSliderWidgetL();

    iBusyIcon = CGlxFullScreenBusyIcon::NewL(*iMediaList,*iUiUtility);

    // create a zoom control

    iZoomControl = CGlxZoomControl::NewL(*this, *iMediaList,

            *iZoomButtonGroup, *iSliderWidget, iGestureHelper);

    // hide the screen furniture

    HideUi(ETrue);

	// Set active media list pointer, so that UPnP renderer knows about this list

    iActiveMediaListRegistry->RegisterActiveMediaList(iMediaList);

	if ( !iPeriodic->IsActive() )

		{

	    iPeriodic->Start(KPeriodicStartDelay, KPeriodicIntervalDelay,

	            TCallBack(&PeriodicCallback, static_cast<TAny*> (this)));

		}

	//Set the animation effect for the coverflow widget since the animation

	//does not work for both avkon and alf together. This can be done since the

	//UI Screen furnitures are disabled by default while going to fullscreen.

	//Check if the transitions are enabled from themes

    if (CAknTransitionUtils::TransitionsEnabled(

                                    AknTransEffect::EFullScreenTransitionsOff))

        {

        if(!iAlfEffectObs)

            {

            iAlfEffectObs = CAlfEffectObserver::NewL();

            }

        const_cast<CAlfLayout&> (iCoverFlowWidget->ContainerLayout()).SetEffectL(

                KTfxResourceActivateFullScreen);

        iEffectHandle = iCoverFlowWidget->ContainerLayout().Identifier();

        iAlfEffectObs->SubscribeCallbackL(this,iEffectHandle);

        }

	//Disable the status pane here as it causes flicker while animating

    CAknViewAppUi* appui = AppUi();

    if ( appui )

        {

        SetTitlePaneTextL(KNullDesC);

        appui->StatusPane()->MakeVisible(EFalse);

        appui->Cba()->MakeVisible(EFalse);

        }

	iViewWidget->show(true);    

	}

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

// Creates a coverflow widget

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

//

void CGlxFullScreenViewImp::CreateCoverflowWidgetL()

    {

    TRACER("CGlxFullScreenViewImp::CreateCoverflowWidgetL");

    const char* KWidgetName("mulcoverflowwidget");

    const char* KCoverflowViewWidget("CoverflowViewWidget");

    const char* KCoverflowWidget("CoverflowWidget");

    try

        {

        // Get widget factory from CAlfEnv

        // Factory is then used to create the individual widgets & data model

        IAlfWidgetFactory& widgetFactory =

                AlfWidgetEnvExtension::widgetFactory(*iEnv);

        // create a view widget  

        iViewWidget = widgetFactory.createViewWidget(KCoverflowViewWidget,

                0x113);

        // hide control and status pane

        iViewWidget->enableControlPane(EFalse);

        iViewWidget->enableStatusPane(EFalse);

        iViewWidget->setRect(TRect(TPoint(0, 0), AlfUtil::ScreenSize()));

        // create coverflow widget

        iCoverFlowWidget = widgetFactory.createWidget<IMulCoverFlowWidget> (

                KWidgetName, KCoverflowWidget, *iViewWidget, NULL);

        iCoverFlowWidget->SetFlags(IMulMultiItemWidget::EMulWidgetDoubleTap);

        // Widget takes the ownership

        iCoverFlowWidget->AddEventHandler(*this);

        iCoverFlowWidget->control()->AcquireFocus();

        iMediaListMulModelProvider = CGlxMediaListMulModelProvider::NewL(

                *iEnv, *iCoverFlowWidget, *iMediaList, iFullScreenBindingSet,

                mulwidget::KTemplate4, KCoverflowDataWindowSize);

        iGestureHelper

                = (GestureHelper::CGestureHelper*) iCoverFlowWidget->Gesturehelper();

        }

    catch(...)

        {

        User::Leave(KErrGeneral);

        }

    }

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

//Initialise the slider widget and the slider model

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

//

void CGlxFullScreenViewImp::CreateSliderWidgetL()

    {

    const char* KSliderWidgetName("mulsliderwidget");

    const char* KZoomSliderWidget("ZoomSliderWidget");

    try

        {

        IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(*iEnv);

        iSliderWidget = widgetFactory.createWidget<IMulSliderWidget>( KSliderWidgetName, 

                KZoomSliderWidget, *iViewWidget, NULL);

        iSliderWidget->AddEventHandler(*this);

        iSliderWidget->SetHandleKeyEvent(EFalse);

        iSliderModel = widgetFactory.createModel<IMulSliderModel> ("mulslidermodel");

        iSliderModel->SetTemplate(ESliderTemplate3);

        iSliderWidget->setModel(iSliderModel);

        iSliderWidget->control()->disableState(IAlfWidgetControl::Focusable);

        //adding the range and slider tick value 

        if(iSliderModel)

            {

            iSliderModel->SetTick(KGlxSliderTickValue);

            }

        }

    catch(...)

        {

        User::Leave(KErrGeneral);

        }

    }