/*

* Copyright (c) 2006 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:  Controller class for handling browser requests to play video

*

*/

// INCLUDE FILES

#include <mmf/common/mmferrors.h>

#include <aknclearer.h>

#include <AknUtils.h>

#include "BavpPlugin.h"

#include "BavpLogger.h"

#include "BavpControllerVideo.h"

#include "BavpView.h"

#include "BavpViewFullScreen.h"

#include <mmf/common/mmfcontrollerframework.h> 

#include <MMFScalingCustomCommandConstants.h>

using namespace RT_GestureHelper;

// CONSTANTS

// One second represented in microseconds

const TInt KBavpOneSecond = 1000000;

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

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

// CBavpControllerVideo::NewL

// Two-phased constructor.

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

CBavpControllerVideo* CBavpControllerVideo::NewL( MBavpView* aView,

                                                  TUint aAccessPtId,

                                                  TBavpMediaType aMediaType,

                                                  const TDesC& aFileName )

    {

    CBavpControllerVideo* self = new( ELeave ) CBavpControllerVideo( aView, aAccessPtId );

    Log( EFalse, _L("CBavpControllerVideo::NewL this="), (TInt)self );

    CleanupStack::PushL( self );

    self->ConstructL( aMediaType, aFileName );

    CleanupStack::Pop( self );

    return self;

    }

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

// CBavpControllerVideo::~CBavpControllerVideo()

// Destructor

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

CBavpControllerVideo::~CBavpControllerVideo()

    {

    Log( EFalse, _L("CBavpControllerVideo::~CBavpControllerVideo this="), (TInt)this );

    // If currently playing, call Stop before you close and delete

    if ( iCurrentState == EBavpPlaying && iVideoPlayer)

        {

        iVideoPlayer->Stop();

        }

    // Close the video plugin, and delete it

    if ( iVideoPlayer )

        {

        iVideoPlayer->Close();

        delete iVideoPlayer;

        }

    // CIdle AO used for display update

    if ( iDisplayUpdater )

        {

        delete iDisplayUpdater;

        }

  if ( iBackLightUpdater )

      {

      iBackLightUpdater->Cancel();

      delete iBackLightUpdater;

      }

    // Used for displaying content in full screen

    if ( iBavpViewFullScreen )

        {

        delete iBavpViewFullScreen;

        }

    }

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

// CBavpControllerVideo::CBavpControllerVideo

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

// might leave.

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

CBavpControllerVideo::CBavpControllerVideo( MBavpView* aView, TUint aAccessPtId )

    : CBavpController( aView, aAccessPtId )

    {

    }

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

// CBavpControllerVideo::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CBavpControllerVideo::ConstructL( TBavpMediaType aMediaType,

                                       const TDesC& aFileName )

    {

    // Construct the BavpController base class

    BaseConstructL( aMediaType, aFileName );

    // Create CIdle (AO) to update the display

    iDisplayUpdater = CIdle::NewL( CActive::EPriorityIdle );

    iBackLightUpdater=CHeartbeat::NewL(CActive::EPriorityStandard);

    }

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

// CBavpControllerVideo::PrepareCompleteL

// Handle the leaving methods needed by MvpuoPrepareComplete

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

void CBavpControllerVideo::PrepareCompleteL()

    {

    // Resolution

    TSize size;

    iVideoPlayer->VideoFrameSizeL(size);

    iClipInfo->iResolutionHeight = size.iHeight;

    iClipInfo->iResolutionWidth = size.iWidth;

    // Bitrate

    iClipInfo->iBitrate = iVideoPlayer->VideoBitRateL() +

                          iVideoPlayer->AudioBitRateL();

    TInt iMetaCount = iVideoPlayer->NumberOfMetaDataEntriesL();

    CMMFMetaDataEntry* metaData = NULL;

    for ( TInt i = 0; i < iMetaCount; i++ )

        {

        metaData = iVideoPlayer->MetaDataEntryL( i );

        Log( EFalse, _L("metaData index="), i );

        Log( EFalse, metaData->Name() );

        Log( EFalse, metaData->Value() );

        // Check if seekable

        if ( !metaData->Name().CompareF( KBavpSeekable ) )

            {

            if ( !metaData->Value().CompareF( KBavpFalse ) )

                {

                iClipInfo->iSeekable = EFalse;

                }

            }

        // Check if live stream

        if ( !metaData->Name().CompareF( KBavpLiveStream ) )

            {

            if ( !metaData->Value().CompareF( KBavpTrue ) )

                {

                // Live stream is not seekable

                iClipInfo->iLiveStream = ETrue;

                iClipInfo->iSeekable = EFalse;

                }

            }

        delete metaData;

        }   // end of for

    // Set up the max volume

    iClipInfo->iMaxVolume = iVideoPlayer->MaxVolume();

    iPlayerMaxVolume = iClipInfo->iMaxVolume;

    // Duration

    iClipInfo->iDurationInSeconds = iVideoPlayer->DurationL();

    // Audio track

    iClipInfo->iAudioTrack = iVideoPlayer->AudioEnabledL();

    // Video track

    iClipInfo->iVideoTrack = iVideoPlayer->VideoBitRateL();

    if ( IsClipSeekable() )

        {

        iVideoPlayer->SetPositionL( iClipInfo->iPosition );

        }

    }

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

// CBavpControllerVideo::InitVideoPlayer

// The non-leaving version that calls the leaving version. Closes the current

// player and prepares the MMF to play the video

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

void CBavpControllerVideo::InitVideoPlayer()

    {

    TRAP_IGNORE( InitVideoPlayerL() );

    }

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

// CBavpControllerVideo::InitVideoPlayerL

// Closes the current player and prepares the MMF to play the video

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

void CBavpControllerVideo::InitVideoPlayerL()

    {

    Log( EFalse, _L("CBavpControllerVideo::InitVideoPlayerL()") );

    // If videoplayer is already opened, close and delete it

    if ( iVideoPlayer )

        {

        iVideoPlayer->Close();

        delete iVideoPlayer;

        iVideoPlayer = NULL;

        }

    // Get the rect to display

    TRect rect( iBavpView->CoeControl().Rect() );

    TPoint pt = iBavpView->WindowInst().AbsPosition();

    rect.Move( pt.iX, pt.iY );

    CEikonEnv* eikon = CEikonEnv::Static();

    RWsSession& ws = eikon->WsSession();

    CWsScreenDevice* screenDevice = eikon->ScreenDevice();

    // Clip rect manipulation.

    // Calculate the rect for display, including title and status pane

    TRect clipRect = GetClipRect( rect );

    Log( EFalse, _L("InitVideoPlayerL() - calling CVideoPlayerUtility::NewL") );

    // Initialize the videoplayer

    iVideoPlayer = CVideoPlayerUtility::NewL( *this, EMdaPriorityNormal,

                                              EMdaPriorityPreferenceNone,

                                              ws, *screenDevice,

                                              iBavpView->WindowInst(), rect,

                                              clipRect);

    // Register for loading notification

    iVideoPlayer->RegisterForVideoLoadingNotification( *this );

    switch ( iClipInfo->iMediaType )

        {

        case ELocalVideoFile:

            Log( EFalse, _L("InitVideoPlayerL() - calling OpenVideoFile") );

            OpenVideoFileL();

            break;

        case ELocalRamFile:

        case EUrl:

        case ELocalSdpFile:

#if defined(BRDO_ASX_FILE)

		case ELocalAsxFile:

#endif // BRDO_ASX_FILE

            Log( EFalse, _L("InitVideoPlayerL() - calling OpenVideoUrlL") );

            OpenVideoUrlL();

            break;

        // Not supported

        case ELocalAudioPlaylist:

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    }

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

// CBavpControllerVideo::UnInitVideoPlayer

// Closes the player and delete the instance

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

void CBavpControllerVideo::UnInitVideoPlayer()

    {

    Log( EFalse, _L("CBavpControllerVideo::UnInitVideoPlayer()") );

    if ( iVideoPlayer )

        {

        iVideoPlayer->Close();

        delete iVideoPlayer;

        iVideoPlayer = NULL;

        }

    iCurrentState = EBavpNone;

    }

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

// CBavpControllerVideo::RotateScreen90

// Rotate the screen if needed

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

void CBavpControllerVideo::RotateScreen90()

    {

    Log( EFalse, _L("CBavpControllerVideo::RotateScreen90()") );

    TRect screenRect;

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

    // Rotate only if screen rect height is greater than its width

    if ( screenRect.Height() > screenRect.Width() )

        {

        TRAP_IGNORE( iVideoPlayer->SetRotationL( EVideoRotationClockwise90 ) );

        }

    }

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

// CBavpControllerVideo::RevertToFullScreenL

// Set full screen display mode

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

void CBavpControllerVideo::RevertToFullScreenL()

    {

    Log( EFalse, _L("CBavpControllerVideo::RevertToFullScreenL()"));

    CBavpPluginEcomMain* npm = (CBavpPluginEcomMain*)Dll::Tls();

    bool fullscreen = true;

    iVideoPlayer->StopDirectScreenAccessL();

    iClipInfo->iInFullScreenMode = ETrue;

    npm->Funcs()->setvalue(iBavpView->bavPlugin()->getNPP(), 

                           NPPVpluginFullScreenBool, 

                           static_cast<void*>(&fullscreen));

    iBavpView->ControllerStateChangedL();

    CEikonEnv* eikon = CEikonEnv::Static();

    RWsSession& ws = eikon->WsSession();

    CWsScreenDevice* screenDevice = eikon->ScreenDevice();

    iNormalScreenRect = iBavpView->CoeControl().Rect();

    TPoint pt = iBavpView->WindowInst().AbsPosition();

    iNormalScreenRect.Move(pt.iX, pt.iY);

    TRect screenRect = eikon->EikAppUi()->ApplicationRect();

    CCoeControl* parentView = iBavpView->CoeControl().Parent();

    parentView->SetRect(screenRect);

    iBavpView->CoeControl().SetExtent(TPoint(0,0), screenRect.Size());

    iVideoPlayer->SetDisplayWindowL( ws, *screenDevice,

                                     iBavpView->WindowInst(),

                                     screenRect, screenRect );

    RotateScreen90();

    }

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

// CBavpControllerVideo::RevertToNormalScreenL

// Set back to normal display mode

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

void CBavpControllerVideo::RevertToNormalScreenL()

    {

     Log( EFalse, _L("CBavpControllerVideo::RevertToNormalScreenL()") );

    CEikonEnv* eikon = CEikonEnv::Static();

    RWsSession& ws = eikon->WsSession();

    CWsScreenDevice* screenDevice = eikon->ScreenDevice();

    CBavpPluginEcomMain* npm = (CBavpPluginEcomMain*)Dll::Tls();

    bool fullscreen = false;

    iVideoPlayer->StopDirectScreenAccessL();

    npm->Funcs()->setvalue(iBavpView->bavPlugin()->getNPP(), 

                               NPPVpluginFullScreenBool, 

                               static_cast<void*>(&fullscreen));

    CCoeControl* parentView = iBavpView->CoeControl().Parent();

    parentView->SetRect(iNormalScreenRect);

    iBavpView->CoeControl().SetExtent(TPoint(0,0), iNormalScreenRect.Size());

    iClipInfo->iInFullScreenMode = EFalse;

    RefreshRectCoordinatesL();

    iVideoPlayer->SetRotationL( EVideoRotationNone );

    iBavpView->ControllerStateChangedL();

    }

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

// CBavpControllerVideo::ToggleScreen

// Start a call back for the display screen switches (Full Screen to

// Normal Screen)

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

void CBavpControllerVideo::ToggleScreen()

    {

    if ( iDisplayUpdater->IsActive() )

        {

        iDisplayUpdater->Cancel();

        }

    iDisplayUpdater->Start( TCallBack( CBavpControllerVideo::WaitForScreenSwitch,

                                       this ) );

    }

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

// CBavpControllerVideo::RefreshRectCoordinatesL

// Refresh the coordinates of rect for display

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

void CBavpControllerVideo::RefreshRectCoordinatesL()

    {

    Log( EFalse, _L("CBavpControllerVideo::RefreshRectCoordinatesL()") );

    if ( IsClipFullScreen() ) {

        return;

    }

    if ( iVideoPlayer )

        {

        TRect rect( iBavpView->CoeControl().Rect() );

        TRect wr(iBavpView->WindowRect()); //can have negative coordinates 

                                           //if video scrolled out of viewport

        // Windows' absolute position, relative to the current screen

        TPoint pt = iBavpView->WindowInst().AbsPosition();

        rect.Move( pt.iX, pt.iY );

        wr.Move( pt.iX, pt.iY );

        CEikonEnv* eikon = CEikonEnv::Static();

        RWsSession& ws = eikon->WsSession();

        CWsScreenDevice* screenDevice = eikon->ScreenDevice();

        // Reset clipRect

        TRect clipRect = rect;

        clipRect = GetClipRect( rect );

        Log( EFalse, _L("\nPosition: == clipRect to DAS:  ==\n") );

        Log( EFalse, _L("\nPosition:: clipRect.x = \n"), clipRect.iTl.iX );

        Log( EFalse, _L("\nPosition:: clipRect.y = \n"), clipRect.iTl.iY );

        Log( EFalse, _L("\nPosition:2: clipRect.x = \n"), clipRect.iBr.iX );

        Log( EFalse, _L("\nPosition:2: clipRect.y = \n"), clipRect.iBr.iY );

		TRAP_IGNORE

		    (

              iVideoPlayer->SetDisplayWindowL( ws, *screenDevice,

            							     iBavpView->WindowInst(),

            							     wr, clipRect );

		    );

    if( iCurrentState == EBavpPaused || iCurrentState == EBavpStopped || iCurrentState == EBavpPlayComplete )

        {

        iVideoPlayer->RefreshFrameL();

        }

        }

    }

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

// CBavpControllerVideo::WaitForScreenSwitch

// Switches between normal screen and full screen

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

TInt CBavpControllerVideo::WaitForScreenSwitch( TAny* aThisData )

    {

    TRAP_IGNORE( WaitForScreenSwitchL( aThisData ) );

    return KErrNone;

    }

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

// CBavpControllerVideo::WaitForScreenSwitch

// Switches between normal screen and full screen

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

void CBavpControllerVideo::WaitForScreenSwitchL( TAny* aThisData )

    {

    Log( EFalse, _L("CBavpControllerVideo::WaitForScreenSwitchL()") );

    // Use static cast

    CBavpControllerVideo* thisData = STATIC_CAST(CBavpControllerVideo*, aThisData);

    // Switch from Normal screen mode to Full Screen mode

    if ( !thisData->IsClipFullScreen() )

        {

        thisData->RevertToFullScreenL();

        }

    else if ( thisData->IsClipFullScreen() )

        {

        // Switch from Full Screen mode to Normal Screen mode

        thisData->RevertToNormalScreenL();

        }

    }

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

// CBavpControllerVideo::DoFastForwardL

// Fast forwards the video

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

TInt CBavpControllerVideo::DoFastForwardL( TAny* aThisData )

    {

    CBavpControllerVideo* thisData = STATIC_CAST( CBavpControllerVideo*, aThisData );

    TTimeIntervalMicroSeconds skipPosition( 0 );

    TTimeIntervalMicroSeconds currentPosition( thisData->iVideoPlayer->PositionL() );

    Log( EFalse, _L("CBavpControllerVideo::DoFastForwardL() - currentPosition = "),

         currentPosition.Int64() );

    // If we're not at the end of clip, skip forward a few positions

    if ( currentPosition < thisData->iClipInfo->iDurationInSeconds )

        {

        skipPosition = currentPosition.Int64() + KSkipToPosition;

        // If skip pass end of clip, set to the end of clip

        if ( skipPosition > thisData->iClipInfo->iDurationInSeconds )

            {

            skipPosition = thisData->iClipInfo->iDurationInSeconds;

            }

        Log( EFalse, _L("CBavpControllerVideo::DoFastForwardL() - skipPosition = "),

             skipPosition.Int64() );

        // Set the position

        thisData->iVideoPlayer->SetPositionL( skipPosition );

        // Refresh the frame

        thisData->iVideoPlayer->RefreshFrameL();

        thisData->iClipInfo->iPosition = skipPosition;

        }

    else

        {

        // Fast Forward reached the end of the clip, cancel the fast forward

        thisData->iPositionUpdater->Cancel();

        thisData->iClipInfo->iPosition = thisData->iClipInfo->iDurationInSeconds;

        // Set the state to complete since it reached the end of the clip

        thisData->iCurrentState = EBavpFastForwardComplete;

        Log( EFalse, _L("CBavpControllerVideo::DoFastForwardL() - End of clip") );

        }

    return ETrue;

    }

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

// CBavpControllerVideo::DoRewindL

// Rewinds the video

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

TInt CBavpControllerVideo::DoRewindL( TAny* aThisData )

    {

    CBavpControllerVideo* thisData = STATIC_CAST( CBavpControllerVideo*, aThisData );

    TTimeIntervalMicroSeconds skipPosition( 0 );

    TTimeIntervalMicroSeconds currentPosition( thisData->iVideoPlayer->PositionL() );