/*

* Copyright (c) 2007-2008 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 Slideshow view

*

*/

// INCLUDE FILES

#include <aknnotewrappers.h> 

#include "shwslideshowview.h"

#include <aknViewAppUi.h>

#include <eikmenub.h>   // for access to CEikButtonGroupContainer (from Cba())

#include <AknUtils.h>	// for CompleteWithAppPath

#include <AknWaitDialog.h>

#include <StringLoader.h>

#include <alf/alfcontrolgroup.h>

#include <alf/alfenv.h>

#include <alf/alfdisplay.h>

#include <alf/alfutil.h>

#include <alf/alfroster.h>

#include <glxhdmicontroller.h>

#include <glxresourceutilities.h>               // for CGlxResourceUtilities

#include <glxresolutionutility.h>               // for CGlxResolutionUtility

#include <shwslideshowview.rsg> // view's resource

#include <data_caging_path_literals.hrh>	// for resource directory path

#include <glxlog.h>

#include <glxtracer.h>

#include <aknsoundsystem.h>				// for CAknKeySoundSystem

#include <avkon.rsg>					// for R_AVKON_SILENT_SKEY_LIST

#include <mpxcollectionpath.h>

#include <coeutils.h> 

#include <eiksoftkeypostingtransparency.h>

#include "mpxcollectionutility.h"

#include "glxfilterfactory.h"  // for TGlxFilterFactory

#include "mglxmedialist.h"

#include "glxuiutility.h"

#include "shwslideshowengine.h"

#include "shweffectinfo.h"

#include "shwslideshowvolumecontrol.h"

#include "shwslideshowbacklighttimer.h"

#include "shwslideshowview.hrh"   // for EShwSlideshowCmdContinue

#include "shwslideshowkeyhandler.h"

#include "shwslideshowpausehandler.h"

#include "shwslideshowtelephonehandler.h"

#include "shwcallback.h"

#include "shwsettingsmodel.h"

#include "shwgesturecontrol.h"

#include "shwviewtimer.h"

#include "shwmediakeyshandler.h"

#include <glxtexturemanager.h>

#include <glxerrormanager.h>             

#include <glxthumbnailattributeinfo.h>   

namespace

    {

    _LIT(KShwSlideshowViewResource,"shwslideshowview.rsc");

    const TInt KShwDefaultDelayMicroSeconds = 5000000;	// 5s

    const TInt KVolumeControlGroupId = 1;

    // Reuse the plug-in's uid

    const TInt KViewId = 0x20007199;

    //gontrol goup id has to be locally unique

    const TInt KShwGestureControlGroupId = 2;

    const TInt KGestureControlGroupId = 44;

    //This constant is used to calculate the index of the item for which texture has to removed.

    //6 = 5(iterator value in forward or backward direction for fullscreen) + 1(focus index)

    const TInt KSlideShowIterator = 2; 

    //Constant which says maximum number of fullscreen textures that we have have at a time.

    //11 = (5(5 fullscreen texture backwards)+1(fucus index texture)+5(5 fullscreen texture forwards))

    const TInt KSlideShowTextureOffset = 3;

    }

//display screen furniture for KShowForSeconds    

const TInt KShowForSeconds = 5;

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

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

// Default constructor. Inlined to save a few bits of ROM

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

// 

inline CShwSlideshowView::CShwSlideshowView() :

        CGlxViewBase(ETrue) // workaround - force synchronous view activation

    {

    TRACER("CShwSlideshowView::CShwSlideshowView");

    GLX_LOG_INFO( "CShwSlideshowView::CShwSlideshowView" );

    }

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

// Two-phased constructor.

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

//

CShwSlideshowView* CShwSlideshowView::NewLC()

    {

    TRACER("CShwSlideshowView::NewLC");

    GLX_LOG_INFO( "CShwSlideshowView::NewLC" );

    CShwSlideshowView* self = new ( ELeave ) CShwSlideshowView;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CShwSlideshowView::~CShwSlideshowView()

    {

    TRACER("CShwSlideshowView::~CShwSlideshowView");

  	GLX_LOG_INFO( "CShwSlideshowView::~CShwSlideshowView()" );

  	delete iMMCNotifier;

  	iMMCNotifier = NULL;

  	// delete media list population call back

    delete iPopulateListCallBack;

    // delete engine async starter

    delete iAsyncCallBack;

    // Cleanup both the lists in case view was not deactivated

    if ( iMediaList )

        {

        iMediaList->Close();

        }

    if ( iFilteredList )

        {

        iFilteredList->Close();

        }

    // Remove the back light timer

    delete iBackLightTimer;

    // Delete the control groups

    if ( iEnv )

        {

        iEnv->DeleteControlGroup( KVolumeControlGroupId );

        iVolumeControlGroup = NULL;

        if(iGestureControlGroup)

            {

            CAlfControl* gesture = (&(iGestureControlGroup->Control(1))); // CGestureControl is 1

            iGestureControlGroup->Remove(gesture);

            }

        iEnv->DeleteControlGroup( KShwGestureControlGroupId );

        iGestureControlGroup = NULL;

    delete iGestureControl;

        }

    // Turn back on the keypad tones

    AppUi()->KeySounds()->PopContext();

    // Delete resource file

    if ( iResourceOffset )

        {

        CCoeEnv::Static()->DeleteResourceFile( iResourceOffset );

        iResourceOffset = NULL;

        }

    }

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

// ShowProgressDialogL.

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

TInt CShwSlideshowView::ShowProgressDialogL()

	{

	TRACER("CShwSlideshowView::ShowProgressDialogL");

  	GLX_LOG_INFO( "CShwSlideshowView::ShowProgressDialogL" );

    // Set to landscape orientation

    // Note that the orientation switch is performed here rather than in the

    // view activation to ensure the correct use of the screen furniture layout

    iUiUtility->SetAppOrientationL( EGlxOrientationLandscape );

    // Set display background as a solid black colour

	iDisplay->SetClearBackgroundL( CAlfDisplay::EClearWithColor );

	// Setup the progress dialog

    iWaitDialog = new ( ELeave ) CAknWaitDialog(

		reinterpret_cast< CEikDialog** >( &iWaitDialog ), ETrue );

    iWaitDialog->PrepareLC( R_SHW_WAIT_NOTE );

    // Dialog is non-modal so request dismissal callbacks

    iWaitDialog->SetCallback( this );

    // Load string for dialog

    HBufC* title = StringLoader::LoadLC( R_SHW_WAIT_DLG_OPENING );

    iWaitDialog->SetTextL( *title );

    CleanupStack::PopAndDestroy( title );

	// Show the dialog, we show it non blocking so no use for the return value

	iWaitDialog->RunLD();

	// set the callback to be engine start

    // if both lists are ready

    if( iInputListReady && iPlayListReady )

        {

    	// make the async callback, this will end up calling StartEngineL()

    	// in CAsyncCallback::RunL once the scheduler next time runs.

    	iAsyncCallBack->CallBack();

        }

    // return value needed as this is a TCallBack

    return KErrNone;

	}

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

// StartEngineL

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

TInt CShwSlideshowView::StartEngineL()

    {

    TRACER("CShwSlideshowView::StartEngineL");

  	GLX_LOG_INFO( "CShwSlideshowView::StartEngineL" );

    // Check that the list has some items

  	if( iFilteredList )

        {

	    TInt filteredCount = iFilteredList->Count();

	    TInt inputlistCount = iMediaList->Count();

	    if ( ( inputlistCount < 1 )||

	         ( filteredCount  < 1 ) )

	        {

	      	GLX_LOG_INFO2( 

	            "CShwSlideshowView::PopulateListL error, counts: %d, %d", 

	                inputlistCount, filteredCount );

	        iEngineStartFailed = ETrue;

	        // need to dismiss the dialog if it's still there

	        if( iWaitDialog )

	            {

	            iWaitDialog->ProcessFinishedL();

	            }

	        }

	    else

	        {

	        // The list should now be populated, so set the focus

	       	SetListFocusL();

	       	// Need to take latest screen size as layout has changed

	       	TRect currentScreen;

	       	TSize screenSize;

	       	AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen,currentScreen);

	       	screenSize = currentScreen.Size();

	    	iEngine->StartL( 

	    	    *iEnv, *iDisplay, *iFilteredList, *this, screenSize );

	        }

        }  

    // return value needed as this is a TCallBack

    return KErrNone;

    }

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

// PopulateListL

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

TInt CShwSlideshowView::PopulateListL()

    {

    TRACER("CShwSlideshowView::PopulateListL");

  	GLX_LOG_INFO( "CShwSlideshowView::PopulateListL" );

    // Setup a filter given the play direction and the path

    CMPXFilter* filter = NULL;

    // take current filter and add the slideshow parameters in it

    // If we play forwards, we dont revert the original order and if we

    // play backwards we need to just revert the original order

    // Note we dont know the original order and cant ask for it as its set by the

    // plug-in and never returned to the client side.

    // we need the full path for the filter creation so that the selection can be 

    // extracted from there

    CMPXCollectionPath* fullpath = iMediaList->PathLC();

    // create the filter

    filter = TGlxFilterFactory::CreateSlideShowFilterFromExistingFilterL( 

        iMediaList->Filter(), fullpath,

        iPlayDirection);

    CleanupStack::PushL( filter );

    // Use this DLL's uid as the hierarchy id

    TGlxHierarchyId hierarchyId = TUid( NShwSlideshow::KEngineDllUid ).iUid;

    iFilteredList = MGlxMediaList::InstanceL( *iCollectionPath, hierarchyId, filter );

    iFilteredList->AddMediaListObserverL( this );

    CleanupStack::PopAndDestroy( filter );

    CleanupStack::PopAndDestroy( fullpath );

    // return value needed as this is a TCallBack

    return KErrNone;

    }

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

// Symbian 2nd phase constructor can leave.

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

// 

void CShwSlideshowView::ConstructL()

    {

    TRACER("CShwSlideshowView::ConstructL");

  	GLX_LOG_INFO( "CShwSlideshowView::ConstructL()" );

	// Load the view's resources

    TFileName resourceFile( KDC_APP_RESOURCE_DIR );

    resourceFile.Append( KShwSlideshowViewResource ); 

    CGlxResourceUtilities::GetResourceFilenameL( resourceFile );  

    iResourceOffset = iCoeEnv->AddResourceFileL( resourceFile );

	// AknView base construction

    BaseConstructL( R_SHW_SLIDESHOW_PLAY_VIEW );

	// Glx view base construction

    ViewBaseConstructL();

    iMMCNotifier = CGlxMMCNotifier::NewL(*this);

    // Create async engine starter with standard priority

	iAsyncCallBack = new( ELeave ) CAsyncCallBack( CActive::EPriorityStandard );

    // Create the back light timer

    iBackLightTimer = CShwSlideshowBackLightTimer::NewL();

	iEnv = iUiUtility->Env();

   	iDisplay = iUiUtility->Display();

    // Construct the volume control

    iVolumeControl = CShwSlideshowVolumeControl::

        NewL( *iEnv,

        	  *iUiUtility,

        	  KShwDefaultDelayMicroSeconds );

    // Create a control group for the volume control

    iVolumeControlGroup = &iEnv->NewControlGroupL( KVolumeControlGroupId );

    // doc says the following takes ownership, but reality is different

	iVolumeControlGroup->AppendL( iVolumeControl );

    iGestureControlGroup = &iEnv->NewControlGroupL( KShwGestureControlGroupId );

	// construct the gesture control group

	iShwGestureControl = CShwGestureControl::NewL(*iEnv,*iDisplay);

	iGestureControlGroup->AppendL( iShwGestureControl );

	GestureHelper::CGestureControl* gestureControl = GestureHelper::CGestureControl::NewLC( 

            *iShwGestureControl, *iEnv, *iDisplay, KGestureControlGroupId );

    iGestureControl = gestureControl;

    CleanupStack::Pop( gestureControl ); // doc says the following takes ownership, but reality is different

	iGestureControlGroup->AppendL( iGestureControl );

	// Need a mechanism to distinguish when we receive the MusicVolume 

	// callback for the first time

	iCurrentVolume = -1;

    iPopulateListCallBack = new( ELeave )

        CAsyncCallBack( CActive::EPriorityStandard );

    // set the callback for the media list population

    iMSKPressed = EFalse;

    iLSKPressed = EFalse;

    }

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

// From CAknView

// Returns views id.

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

//

TUid CShwSlideshowView::Id() const

    {

    TRACER("CShwSlideshowView::Id()");

    GLX_LOG_INFO( "CShwSlideshowView::Id()" );

    return TUid::Uid( KViewId );

    }

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

// From CAknView

// Foreground event handling function.

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

//

void CShwSlideshowView::HandleForegroundEventL(TBool aForeground)

    {

    TRACER("CShwSlideshowView::HandleForegroundEventL");

  	GLX_LOG_INFO( "CShwSlideshowView::HandleForegroundEventL()" );

	iIsForegrnd = aForeground;

    if( aForeground )

        {

        // we gained the foreground

        if(iMMCState && iPrevNotInBackground)

            {

            ProcessCommandL(EAknSoftkeyClose);

            }

        else

            {

            iPauseHandler->SwitchToForegroundL();

            }

        }

    else

        {

        // Something else has gained the foreground

        iPauseHandler->SwitchToBackgroundL();

        }

    CAknView::HandleForegroundEventL(aForeground);

    }

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

// From CGlxViewBase

// DoViewActivateL.

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

void CShwSlideshowView::DoViewActivateL(const TVwsViewId& /*aPrevViewId*/,

										TUid /*aCustomMessageId*/,

										const TDesC8& aCustomMessage)

    {

    TRACER("CShwSlideshowView::DoViewActivateL");

    GLX_LOG_INFO( "CShwSlideshowView::DoViewActivateL()" );

    // remove the status pane

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

    //make the softkeys invisible

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

	// Hide the application toolbar when slide show is started 

	if ( AppUi()->PopupToolbar() ) 

		{

	    AppUi()->PopupToolbar()->SetToolbarVisibility( EFalse );

		AppUi()->PopupToolbar()->MakeVisible(EFalse);

		}	

	iHdmiActive = EFalse;

    // reset failure flag

    iEngineStartFailed = EFalse;

	if(!iHdmiController)

		{

	    iHdmiController = CGlxHdmiController::NewL();

		}

    // Engine related construction

    // Instantiate the slideshow engine, with this class as its observer

    __ASSERT_DEBUG( !iEngine, Panic( EGlxPanicAlreadyInitialised ) );

    iEngine = CShwSlideshowEngine::NewL( *this );

    // Instantiate the pause handler, it encapsulates the pause rules

    __ASSERT_DEBUG( !iPauseHandler, Panic( EGlxPanicAlreadyInitialised ) );

    iPauseHandler = CShwSlideShowPauseHandler::NewL( *iEngine );

    // Instantiate the key handler, encapsulates all key handling logic

    __ASSERT_DEBUG( !iKeyHandler, Panic( EGlxPanicAlreadyInitialised ) );

    iKeyHandler = CShwSlideShowKeyHandler::NewL( *iEngine, *iPauseHandler,

                                                  reinterpret_cast<TInt&>(iShwState ));

    AppUi()->AddToStackL( iKeyHandler, ECoeStackPriorityDefault,

        ECoeStackFlagRefusesFocus );

    // Create the telephone call handler

    __ASSERT_DEBUG( !iTelephoneHandler, Panic( EGlxPanicAlreadyInitialised ) );

    iTelephoneHandler = CShwTelephoneHandler::NewL( *iEngine, *iPauseHandler );

    iTelephoneHandler->StartL();

    // Extract the media list's path and the playback direction from

    // the custom message data

    GetPathAndPlaybackDirectionL( aCustomMessage );

    // Ensure the back light stays on

    iBackLightTimer->StartL();

    // Request asynch callback that will end up in ShowProgressDialogL

    // once the active scheduler runs

    iAsyncCallBack->CallBack();

    iDisplay->Roster().ShowL( *iGestureControlGroup,KAlfRosterShowAtTop );

    iTicker = CShwTicker::NewL(*this);

    InitializeShwFurnitureL();

    iUiUtility->Display()->SetVisibleArea(TRect(TPoint(0,0),AlfUtil::ScreenSize()));

	// We will require to act on events ONLY when the view is active.

	// So listen to them only when the view is active.

    iShwGestureControl->AddObserver(this);

    }

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

// From CGlxViewBase

// DoViewDeactivate.

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

void CShwSlideshowView::DoViewDeactivate()

    {

    TRACER("CShwSlideshowView::DoViewDeactivate");

    GLX_LOG_INFO( "CShwSlideshowView::DoViewDeactivate()" );

    if (iHdmiController)

        {

        GLX_LOG_INFO( "CShwSlideshowView::DoViewDeactivate() - delete hdmicontroller" );

        delete iHdmiController;

        iHdmiController = NULL;

        }

    //check if we have engine active object starting

    if( iPopulateListCallBack->IsActive() )

        {

        //cancel the engine start

        iPopulateListCallBack->Cancel();

        }

    //check if we have engine active object starting

    if( iAsyncCallBack->IsActive() )

        {