/*

* 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 "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 MPXVideoPlaybackControlsController

*

*/

// Version : %version: 24 %

// INCLUDE FILES

#include <fbs.h>

#include <coecntrl.h>

#include <gulicon.h>

#include <bautils.h>

#include <eiklabel.h>

#include <eikimage.h>

#include <AknUtils.h>

#include <barsread.h>

#include <AknIconUtils.h>

#include <StringLoader.h>

#include <AknsDrawUtils.h>

#include <AknsSkinInstance.h>

#include <AknBitmapAnimation.h>

#include <AknsBasicBackgroundControlContext.h>

#include <f32file.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <data_caging_path_literals.hrh>

#include <mpxvideoplaybackcontrols.rsg>

#include <mpxvideoplaybackcontrols.mbg>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_TACTILE_FEEDBACK

#include "mpxvideoplaybackcontrol.h"

#include "mpxvideoplaybackcontrolpdl.h"

#include "mpxvideoplaybackbuttonbar.h"

#include "mpxvideoplaybackvolumebar.h"

#include "mpxvideoplaybackprogressbar.h"

#include "mpxvideoplaybackcontainer.h"

#include "mpxvideoplaybackcontrolpolicy.h"

#include "mpxvideoplaybackviewfiledetails.h"

#include "mpxvideoplaybackcontrolscontroller.h"

#include "mpxvideoplaybackcontrolconfiguration.h"

#include "mpxvideoplaybackaspectratioicon.h"

#include "mpxvideoplaybackbrandinganimation.h"

#include "mpxvideoplaybackmediadetailsviewer.h"

#include "mpxcommonvideoplaybackview.hrh"

using namespace AknLayoutScalable_Apps;

using namespace AknLayoutScalable_Avkon;

const TInt KMPXControlsTimeOut = 4000000;

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

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

// CMPXVideoPlaybackControlsController::CMPXVideoPlaybackControlsController

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

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

//

CMPXVideoPlaybackControlsController::CMPXVideoPlaybackControlsController(

    CMPXVideoPlaybackContainer* aContainer, TRect aRect )

    : iControls( EMPXControlsCount ),

      iRect( aRect ),

      iContainer( aContainer )

{

}

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

// CMPXVideoPlaybackControlsController::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CMPXVideoPlaybackControlsController::ConstructL( CMPXVideoPlaybackViewFileDetails* aDetails )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackControlsController::ConstructL()"));

    User::LeaveIfError( iFs.Connect() );

    _LIT( KMPXVideoPlaybackRscPath, "mpxvideoplaybackcontrols.rsc" );

    TParse parse;

    parse.Set( KMPXVideoPlaybackRscPath, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName resourceFile = parse.FullName();

    //

    //  Find the resource file.  It must be on the same drive as the DLL is installed

    //

    User::LeaveIfError( AddDllPath( resourceFile ) );

    BaflUtils::NearestLanguageFile( iFs, resourceFile );

    CCoeEnv* coeEnv = CCoeEnv::Static();

    MPX_DEBUG(_L("CMPXVideoPlaybackControlsController::ConstructL() rsc file %S"), &resourceFile);

    iVideoResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    iFileDetails = aDetails;

    iFileDetails->iRNFormat = IsRealFormatL( iFileDetails->iClipName->Des() );

    if ( iFileDetails->iRNFormat )

    {

    	CreateRealOneBitmapL();

    }

    iControlsPolicy = CMPXVideoPlaybackControlPolicy::NewL();

    iControlsConfig = CMPXVideoPlaybackControlConfiguration::NewL( this );

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

    CreateControlsL();

#ifdef RD_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

#endif //RD_TACTILE_FEEDBACK

}

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

// CMPXVideoPlaybackControlsController::NewL()

// Two-phased constructor.

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

//

EXPORT_C CMPXVideoPlaybackControlsController* CMPXVideoPlaybackControlsController::NewL(

        CMPXVideoPlaybackContainer* aContainer,

        TRect aRect,

        CMPXVideoPlaybackViewFileDetails* aDetails )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackControlsController::NewL()"));

    CMPXVideoPlaybackControlsController* self =

        new (ELeave) CMPXVideoPlaybackControlsController( aContainer, aRect );

    CleanupStack::PushL(self);

    self->ConstructL( aDetails );

    CleanupStack::Pop();

    return self;

}

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

// CMPXVideoPlaybackControlsController::~CMPXVideoPlaybackControlsController

// Destructor.

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

//

EXPORT_C CMPXVideoPlaybackControlsController::~CMPXVideoPlaybackControlsController()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackControlsController::~CMPXVideoPlaybackControlsController"));

    iFs.Close();

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->RemoveFeedbackForControl( iContainer );

    }

#endif //RD_TACTILE_FEEDBACK

    if ( iControlsPolicy )

    {

        delete iControlsPolicy;

        iControlsPolicy = NULL;

    }

    if ( iControlsConfig )

    {

        delete iControlsConfig;

        iControlsConfig = NULL;

    }

    if ( iControlsTimer )

    {

        iControlsTimer->Cancel();

        delete iControlsTimer;

        iControlsTimer = NULL;

    }

    iControls.ResetAndDestroy();

    if ( iRealOneBitmap )

    {

        delete iRealOneBitmap;

        iRealOneBitmap = NULL ;

    }

    if ( iVideoResourceOffset )

    {

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

    }

    if ( iMediaDetailsViewerControl )

    {

        delete iMediaDetailsViewerControl;

        iMediaDetailsViewerControl = NULL;

    }

}

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

// CMPXVideoPlaybackControlsController::AddFileDetailsL()

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

//

EXPORT_C void CMPXVideoPlaybackControlsController::AddFileDetailsL(

    CMPXVideoPlaybackViewFileDetails* aDetails )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackControlsController::AddFileDetailsL()"));

    iFileDetails = aDetails;

    iFileDetails->iRNFormat = IsRealFormatL( iFileDetails->iClipName->Des() );

    iControlsConfig->UpdateControlsWithFileDetailsL();

    ControlsListUpdatedL();

    //

    //  Show controls initially if this doens't have playable video track

    //

    for ( TInt i = 0 ; i < iControls.Count() ; i++ )

    {

        iControls[i]->UpdateControlsWithFileDetailsL( iFileDetails );

    }

}

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

// CMPXVideoPlaybackControlsController::HandleEventL

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

//

EXPORT_C void CMPXVideoPlaybackControlsController::HandleEventL(

    TMPXVideoPlaybackControlCommandIds aEvent, TInt aValue )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackControlsController::HandleEventL(%d)"), aEvent);

    switch ( aEvent )

    {

        case EMPXControlCmdSetPosition:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdSetPosition [%d]]"), aValue );

            PositionChangedL( (TReal)aValue / (TReal)KPbMilliMultiplier);

            break;

        }

        case EMPXControlCmdSetDuration:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdSetDuration [%d]]"), aValue );

            DurationChangedL( (TReal)aValue / (TReal)KPbMilliMultiplier );

            break;

        }

        case EMPXControlCmdStateChanged:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdStateChanged]"));

            HandleStateChange( (TMPXPlaybackState)aValue );

            break;

        }

        case EMPXControlCmdToggleVisibility:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdToggleVisibility]"));

            ToggleVisibility();

            break;

        }

        case EMPXControlCmdSetVolume:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdSetVolume [%d]]"), aValue );

            VolumeChanged( aValue );

            break;

        }

        case EMPXControlCmdSetAspectRatio:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdSetAspectRatio %d]"), aValue);

            AspectRatioChanged( aValue );

            break;

        }

        case EMPXControlCmdSetDownloadSize:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdSetDownloadSize [%d]]"), aValue );

            SetDownloadSize( aValue );

            break;

        }

        case EMPXControlCmdDownloadUpdated:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdDownloadUpdated [%d]]"), aValue );

            UpdateDownloadPosition( aValue );

            break;

        }

        case EMPXControlCmdDownloadComplete:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdDownloadComplete [%d]]"), aValue);

            UpdateDownloadPosition( aValue );

            break;

        }

        case EMPXControlCmdSetDownloadPaused:

        case EMPXControlCmdClearDownloadPaused:

        {

            iControlsConfig->UpdateControlListL( aEvent );

            ControlsListUpdatedL();

            break;

        }

        case EMPXControlCmdTvOutConnected:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdTvOutConnected]"));

            HandleTvOutEventL( ETrue, aEvent, aValue );

            break;

        }

        case EMPXControlCmdTvOutDisconnected:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdTvOutDisConnected]"));

            HandleTvOutEventL( EFalse, aEvent, aValue );

            break;

        }

        case EMPXControlCmdHandleBackgroundEvent:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdHandleBackgroundEvent]"));

            ResetDisappearingTimers( EMPXTimerReset );

            for ( TInt i = 0 ; i < iControls.Count() ; i++ )

            {

                iControls[i]->ResetControl();

            }

            break;

        }

        case EMPXControlCmdHandleErrors:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdHandleErrors]"));

            HandleErrors();

            break;

        }

        case EMPXControlCmdShowControls:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdShowControls]"));

            ShowControls();

            break;

        }

        case EMPXControlCmdHideControls:

        {

            MPX_DEBUG(_L("    [EMPXControlCmdHideControls]"));

            HideAllControls();

            break;

        }

        case EMPXControlCmdSoftKeyPressed:

        {

            HandleSoftKeyPressedL( aValue );

            break;

        }

        case EMPXControlCmdShowFileDetailsViewer:

        {

            ShowMediaDetailsViewerL();

            break;

        }

        case EMPXControlCmdCloseFileDetailsViewer:

        {

            ShowControls();

            break;

        }

        case EMPXControlCmdSurfaceCreated:

		{

			//

			//  When surface is created, remove the Real One Bitmap

			//

			SetRealOneBitmapVisibility( EFalse );

			break;

		}

    }

}

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

// CMPXVideoPlaybackControlsController::HandleStateChange

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

//

void CMPXVideoPlaybackControlsController::HandleStateChange( TMPXPlaybackState aNewState )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackControlsController::HandleStateChange()"),

                   _L("new state = %d"), aNewState );

    //

    // Somehow EPbStatePlaying, EPbStatePaused gets called twice continously

    //

    if ( aNewState != iState )

    {

    	TBool hideControls( EFalse );

        iState = aNewState;

        switch ( aNewState )

        {

            case EPbStateInitialised:

            {

                //

                //  remove branding control when the state is transitioned to Initialized

                //

                if ( iFileDetails->iPlaybackMode == EMPXVideoStreaming ||

                     iFileDetails->iPlaybackMode == EMPXVideoLiveStreaming )

                {

                    iControlsConfig->UpdateControlListL( EMPXControlCmdPluginInitialized );

                    ControlsListUpdatedL();

                }

                break;

            }

            case EPbStatePlaying:

            {

                if ( iFileDetails->iVideoEnabled && ! IsTvOutConnected() )

                {

                    //

                    //  Hide controls when transitioning to Playing State

                    //

                    hideControls = ETrue;

                }

                //

                //  Intentionally fall through

                //

            }

            case EPbStateBuffering:

            case EPbStateNotInitialised:

            case EPbStateInitialising:

            case EPbStatePaused:

            case EPbStatePluginSeeking:

            {

                UpdateStateOnButtonBar();

                //

                //  Show all the controls

                //

                if ( hideControls )

                {

                    HideAllControls();

                }

                else

                {

                	UpdateControlsVisibility();

                }

                break;

            }

        }

    }

}

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

// CMPXVideoPlaybackControlsController::CreateControlsL()

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

//

void CMPXVideoPlaybackControlsController::CreateControlsL()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackControlsController::CreateControlsL()"));

    //

    //  Clean up old controls list and controls

    //

    iControls.ResetAndDestroy();

    RArray<TMPXVideoPlaybackControls>& controlList = iControlsConfig->ControlList();

    //

    //  Iterate thru the controls list from view-config

    //  and create controls that match items in the list

    //

    for ( TInt i = 0 ; i < controlList.Count() ; i++ )

    {

        AppendControlL( controlList[i] );

    }

    UpdateControlsVisibility();

}

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

// CMPXVideoPlaybackControlsController::CreateRealOneBitmapL()

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

//

void CMPXVideoPlaybackControlsController::CreateRealOneBitmapL()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackControlsController::CreateRealOneBitmapL()"));

    TFileName iconsPath;

    LocateBitmapFileL( iconsPath );

    iRealOneBitmap = CreateBitmapL( iconsPath,

                                    EMbmMpxvideoplaybackcontrolsQgn_graf_realplayer_splash_01,

                                    main_mp4_pane_g1(0).LayoutLine() );

}

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

// CMPXVideoPlaybackControlsController::GetBitmap()

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

//

EXPORT_C CEikImage*

CMPXVideoPlaybackControlsController::GetBitmap( TMPXVideoPlaybackControls aBitmap )

{

    CEikImage* bitmap = NULL;

    switch( aBitmap )

    {

        case EMPXRealLogoBitmap:

        {

            bitmap = iRealOneBitmap;

            break;

        }

    }

    return bitmap;

}

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

// CMPXVideoPlaybackControlsController::ControlsListUpdatedL()

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

//

void CMPXVideoPlaybackControlsController::ControlsListUpdatedL()