/*

* Copyright (c) 2005 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:  

*       MsgEditor video media control - a Message Editor Base control.

*

*/

// INCLUDE FILES

#include "MsgVideoControl.h"

#include <AudioPreference.h>

#include <AknsDrawUtils.h>

#include <DRMCommon.h>

#include <mmf/common/mmferrors.h>              // KErrMMPartialPlayback

#include <MsgEditorCommon.h>

#include "MsgFrameControl.h"

#include "MsgIconControl.h"

#include "MsgVideoAreaControl.h"

#include "MsgMediaControlLogging.h"

// ==========================================================

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

//used to reset inactivity timer after one sec so that backlight will not

// be turned on during video playback.

const TInt KResetInactivityAfterOneSecond = 2000000;   // 2s

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

// CMsgVideoControl::CMsgVideoControl

//

// Constructor. Maximum video area is calculated so that height comes from 

// mainpane height and width comes from data pane height. This video will

// use whole application area excluding scrollbar area.

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

//

CMsgVideoControl::CMsgVideoControl( MMsgBaseControlObserver& aBaseControlObserver,

                                    TMdaPriority aPriority,

                                    TMdaPriorityPreference  aPreference,

                                    TInt aFlags ) :

    CMsgMediaControl( aBaseControlObserver, EMsgComponentIdVideo, EMsgVideoControl ),

    iMaxVideoArea( MsgEditorCommons::MsgMainPane() ),

    iMaxVolume( 1 ),

    iFlags( aFlags ),

    iHasVideo( ETrue ),

    iPriority( aPriority ),

    iPreference( aPreference )

    {

    if ( iFlags & ENoPlayback )

        {

        iControlType = EMsgImageControl;

        }

    iMaxVideoArea.SetWidth( MsgEditorCommons::MsgDataPane().Width() );

    }

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

// CMsgVideoControl::ConstructL

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

//

void CMsgVideoControl::ConstructL( CMsgEditorView& aParent, MMsgAsyncControlObserver* aObserver )

    {

    BaseConstructL( aParent, aObserver );

    SetRect( iMaxVideoArea );

    iTimer = CPeriodic::NewL( EPriorityLow );

    }

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

// CMsgVideoControl::NewL

//

// Two-phased constructor.

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

//

EXPORT_C CMsgVideoControl* CMsgVideoControl::NewL( CMsgEditorView& aParent,

                                                   MMsgAsyncControlObserver* aObserver,

                                                   TMdaPriority aPriority,

                                                   TMdaPriorityPreference  aPreference,

                                                   TInt aFlags )

    {

    CMsgVideoControl* self = new( ELeave ) CMsgVideoControl( aParent, aPriority, aPreference, aFlags );

    CleanupStack::PushL( self );

    self->ConstructL( aParent, aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMsgVideoControl::~CMsgVideoControl

//

// Destructor

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

//

CMsgVideoControl::~CMsgVideoControl()

    {

    delete iVideoPlayer;

    delete iIdle;

    iVideoFile.Close();

    delete iTimer;

    delete iVideoAreaControl;

    }

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

// CMsgVideoControl::HasAudio

//

// Check if video clip has audio in.

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

//

EXPORT_C TBool CMsgVideoControl::HasAudioL( void ) const

    {

    if ( iVideoPlayer && Error() == KErrNone )

        {

        return iVideoPlayer->AudioEnabledL();

        }

    return EFalse;

    }

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

// CMsgVideoControl::SetVolume

//

// Set volume level.

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

//

EXPORT_C void CMsgVideoControl::SetVolumeL( TInt aVolume )

    {

    MSGMEDIACONTROLLOGGER_WRITEF( _L("MsgVideoControl::SetVolumeL(): HasAudioL(): %d, iMaxVolume: %d, aVolume: %d"),  HasAudioL(), iMaxVolume, aVolume);

    if ( HasAudioL() )

        {

        iVideoPlayer->SetVolumeL( aVolume );

        iVolume = iVideoPlayer->Volume();

        }

    }

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

// CMsgVideoControl::FocusChanged

//

// Called when focus is changing. Playing is paused or stopped

// depending on iContinueOnFocus flag when focus moves out of video control. 

// When focus moved back to control playing is started automatically

// if iContinueOnFocus flag is set.

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

//

void CMsgVideoControl::FocusChanged( TDrawNow aDrawNow )

    {

    MSGMEDIACONTROLLOGGER_WRITEF( _L("MsgVideoControl : FocusChanged: IsFocused(): %d" ), IsFocused() );

    if ( IsFocused() )

        {

        if ( iState == EMsgAsyncControlStatePaused &&

             iContinueOnFocus )

            {

            MSGMEDIACONTROLLOGGER_WRITE( "MsgVideoControl : FocusChanged - Delayed start **" );

            // We must use CIdle to perform Play since

            // "SizeChanged" event comes only after "FocusChanged"

            // and thus the coordinates of the video control might

            // be false at this stage.

            delete iIdle;

            iIdle = NULL;

            TRAP_IGNORE( iIdle = CIdle::NewL( CActive::EPriorityIdle ) );

            if ( iIdle ) 

                {

                iIdle->Start( TCallBack( DelayedPlay, this ) );

                }

            else

                {

                MSGMEDIACONTROLLOGGER_WRITE( "MsgVideoControl : FocusChanged - Error in creating iIdle **" );

                Stop();

                }

            }

        }

    else

        {

        if ( iContinueOnFocus && 

             iState == EMsgAsyncControlStatePlaying )

            {

            MSGMEDIACONTROLLOGGER_WRITE( "MsgVideoControl : FocusChanged - Pausing video ..." );

            TRAPD( err, PauseL() );

            if ( err )

                {

                MSGMEDIACONTROLLOGGER_WRITE( "MsgVideoControl : FocusChanged - Error in pausing -> Stop it **" );

                Stop();

                }

            }

        else

            {

            MSGMEDIACONTROLLOGGER_WRITE( "MsgVideoControl : FocusChanged - Stopping video **" );

            Stop();

            }

        }

    CMsgMediaControl::FocusChanged( aDrawNow );

    }

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

// CMsgVideoControl::SetAndGetSizeL

//

// Calculates and sets the size of the control and returns new size as

// reference aSize. Video control uses the whole application area excluding

// area that has been reserved for scrollbar when it is used for playback.

// Otherwise it uses the same width but height is calculated so that

// it will icon height + one line height and rounded up to the next whole line.

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

//

void CMsgVideoControl::SetAndGetSizeL( TSize& aSize )

    {

    MSGMEDIACONTROLLOGGER_WRITEF( _L("MsgVideoControl:: SetAndGetSizeL(): Size: %dx%d"),  aSize.iWidth, aSize.iHeight);

    aSize.iWidth = iMaxVideoArea.Width();

    if ( iFlags & ENoPlayback )

        {

        aSize.iHeight = iFrame->FrameSize().iHeight;

        if ( aSize.iHeight % iLineHeight != 0 )

            {

            aSize.iHeight += iLineHeight - ( aSize.iHeight % iLineHeight );

            }

        aSize.iHeight += iLineHeight;

        }

    else

        {

        aSize.iHeight = iMaxVideoArea.Height();

        }

    MSGMEDIACONTROLLOGGER_WRITEF( _L("MsgVideoControl:: SetAndGetSizeL(): New size: %dx%d"),  aSize.iWidth, aSize.iHeight);

    SetSize( aSize );

    }

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

// CMsgVideoControl::Reset

//

// Empties the control and sets icon visible.

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

//

void CMsgVideoControl::Reset()

    {

    if( iVideoPlayer )

        {

        iVideoPlayer->Stop();

        iVideoPlayer->Close();

        iTimer->Cancel();

        delete iVideoPlayer;

        iVideoPlayer = NULL;

        }

    iVideoFile.Close();

    iVolume = 0;

    iMaxVolume = 1;

    SetIconVisible( ETrue );

    if ( iVideoAreaControl )

    	{

        iVideoAreaControl->MakeVisible( EFalse );

    	}

    iControlModeFlags |= EMsgControlModeModified;

    SetState( EMsgAsyncControlStateIdle );

    }

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

// CMsgVideoControl::Draw

// Draw the skin background when appriate. Normal icon drawing

// is performed when icon is visible. Otherwise when video frame

// is visible we just draw the control area around the video frame.

// Video controller is responsible of drawing the video frame area.

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

//

void CMsgVideoControl::Draw( const TRect& aRect ) const

    {

    MSGMEDIACONTROLLOGGER_ENTERFN( "MsgVideoControl : Draw()" );

    if ( VisiblePlaceholder() )

        {    

        // Basic icon drawing from base class when icon is visible.

        CMsgMediaControl::Draw( aRect );    

        }

    else 

        {

        if ( !AknsDrawUtils::BackgroundBetweenRects( AknsUtils::SkinInstance(), 

                                                      AknsDrawUtils::ControlContext( this ), 

                                                      this, 

                                                      SystemGc(), 

                                                      aRect,

                                                      iVideoFrameArea ) )

            {

            SystemGc().SetBrushColor( AKN_LAF_COLOR( 0 ) );

            SystemGc().SetBrushStyle( CGraphicsContext::ESolidBrush );

            SystemGc().SetPenStyle( CGraphicsContext::ENullPen );

            SystemGc().DrawRect( aRect );

            }

        if ( !Window().IsFaded() )

            {

            // Should prevent race conditions between DSP ans window server.

            iCoeEnv->WsSession().Flush();

            TRAP_IGNORE( iVideoPlayer->RefreshFrameL() ) ;

            }

        }        

    }

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

// CMsgVideoControl::HandleResourceChange

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

//

void CMsgVideoControl::HandleResourceChange( TInt aType )

    {

    CMsgMediaControl::HandleResourceChange( aType ); 

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        Stop();

        TRAP_IGNORE( UpdateScaleFactorL() );

        iMaxVideoArea = MsgEditorCommons::MsgMainPane();

        iMaxVideoArea.SetWidth( MsgEditorCommons::MsgDataPane().Width() );

        }

    }

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

// CMsgVideoControl::SizeChanged

//

// Called when size is changed.

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

//

void CMsgVideoControl::SizeChanged()

    {

    MSGMEDIACONTROLLOGGER_WRITEF( _L("MsgVideoControl:: SizeChanged(): New size: %dx%d"),  Size().iWidth, Size().iHeight);

    CMsgMediaControl::SizeChanged();

    SetPosition( Rect().iTl );

    MSGMEDIACONTROLLOGGER_WRITEF( _L("MsgVideoControl:: SizeChanged(): Rect().iTl %dx%d"),  Rect().iTl.iX, Rect().iTl.iY);

    if ( iVideoPlayer && Error() == KErrNone )

        { 

        TRAP_IGNORE( SetVideoFrameSizeL() );

        }

    }

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

// CMsgVideoControl::LoadL

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

//

void CMsgVideoControl::LoadL( RFile& aFileHandle )

    {

    MSGMEDIACONTROLLOGGER_ENTERFN( "MsgVideoControl : LoadL()" );

    iVideoFile.Close();

    User::LeaveIfError( iVideoFile.Duplicate( aFileHandle ) );

    if ( !iVideoAreaControl )

    	{

        iVideoAreaControl = CMsgVideoAreaControl::NewL( this );

    	}

    if ( !iVideoPlayer )

        {

        // Disable frame display as video is not yet visible

        TRect rect;

        TRect clipRect;

        // Create VideoPlayerUtility instance

        iVideoPlayer = CVideoPlayerUtility::NewL(

                        *this,

                        iPriority,

                        iPreference,

                        ControlEnv()->WsSession(),

                        *ControlEnv()->ScreenDevice(),    

                        *iVideoAreaControl->DrawableWindow(),

                        rect, 

                        clipRect );

        // Register for Loading/rebuffering notices

        iVideoPlayer->RegisterForVideoLoadingNotification( *this );

        }

    else

        {

        iVideoPlayer->Close();

        }

    TMMFileHandleSource mmSource( iVideoFile, iUniqueContentId );

    iVideoPlayer->OpenFileL( mmSource );        

    SetState( EMsgAsyncControlStateOpening );

    MSGMEDIACONTROLLOGGER_LEAVEFN( "MsgVideoControl : LoadL()" );

    }

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

// CMsgVideoControl::Cancel

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

//

void CMsgVideoControl::Cancel()

    {

    if ( iState == EMsgAsyncControlStateOpening )

        {

        iVideoPlayer->Close();

        SetState( EMsgAsyncControlStateIdle );

        }

    }

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

// CMsgVideoControl::VideoResolution

//

// Gives the resolution of the video in display (Symbian OS bitmap)

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

//

EXPORT_C TSize CMsgVideoControl::VideoResolutionL() const

    {

    TSize retVal( 0, 0 );

    if ( iVideoPlayer && Error() == KErrNone )

        {

        iVideoPlayer->VideoFrameSizeL( retVal );

        }

    return retVal;

    }

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

// DelayedExit

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

//

TInt CMsgVideoControl::DelayedPlay( TAny* aThis )

    {

    TRAPD( error, static_cast<CMsgVideoControl*>( aThis )->PlayL() );

    return error;

    }

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

// CMsgVideoControl::PlayL

//

// Starts video playback.

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

//

void CMsgVideoControl::PlayL()

    {

    MSGMEDIACONTROLLOGGER_ENTERFN( "MsgVideoControl : PlayL()" );

    // When DSP is used for audio/video playing, dsp resources are not always available.

    // It is handled by setting normal 'ready' icon. No error notes occur.

    if ( iVideoPlayer && 

         (  Error() == KErrNone ||

            (   iState == EMsgAsyncControlStateCorrupt

            &&  (   Error() == KErrAccessDenied

                ||  Error() == KErrSessionClosed ) ) ) && 

         !( iFlags & ENoPlayback ) )

        {

        if ( iHasVideo )

            {

            // Only hide icon if video file has video stream.

            if ( iIconControl->IsVisible() )

                {

                UpdateScaleFactorL();

                SetIconVisible( EFalse );

                iVideoAreaControl->MakeVisible( ETrue );

                // Enable frame display        	

                SetVideoFrameSizeL();

                }

            iTimer->Cancel(); //just in case

            // Disable backlight turn off during video playback when video contains

            // video stream.

            iTimer->Start( KResetInactivityAfterOneSecond,

                           KResetInactivityAfterOneSecond,

                           TCallBack( DoResetInactivityTimer, NULL ) );

            }

        iVideoPlayer->Play();

        if ( iState == EMsgAsyncControlStatePaused )

            {

            SetState( EMsgAsyncControlStatePlaying );

            }

        else

            {

            if (iState == EMsgAsyncControlStateReady )

                {

                // First time

                SetState( EMsgAsyncControlStateAboutToPlay );

                }

            else

                {

                // State must be stop. Video has earlier played

                SetState( EMsgAsyncControlStatePlaying );

                }

            }

        }