/*

* 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:  This class plays local video file

 *

*/

//

//  INCLUDE FILES

//

#include <eikenv.h>

#include <mpxcenrepobserver.h>

#include <mpxcenrepwatcher.h>

#include <mpxmediageneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmediageneralextdefs.h>

#include <mpxplaybackcommanddefs.h>

#include <mpxplaybackpluginobserver.h>

#include <mpxplaybackplugin.h>

#include <AudioPreference.h>

#include <mpxplaybackplugin.h>

#include <coreapplicationuisdomainpskeys.h>

#include <ctsydomainpskeys.h>

#include <mmf/common/mmferrors.h>

#include <hal.h>

#include <hal_data.h>

#include <e32std.h>

#include <devsoundif.h>

#include "mpxvideoregion.h"

#include "mpxvideoplaybackcontroller.h"

#include "mpxvideoplaybackstate.h"

#include "mpxvideoprivatecrkeys.h"

#include "mpxvideohelixplayback.h"

#include "mpxvideoseeker.h"

#include "mpxvideoplayerutility.h"

#include "mpxvideodrmhelper.h"

#include <mpxvideoplaybackdefs.h>

#include "mpxmediavideodefs.h"

//

//  CONSTANTS

//

#define KMAXMIMETYPELENGTH 256

//

//  Backlight Timeout in Micro Seconds

//

#define KMPXBackLightTimeOut 3500000

#define KOneKilobyte 1024

_LIT( KTitle, "Title" );

_LIT( KLiveStream, "LiveStream" );

_LIT( KSeekable, "Seekable" );

_LIT( KArtist, "Artist" );

_LIT( KAuthor, "Author" );

_LIT( KFormat, "MimeType" );

_LIT( KTrue, "1" );

_LIT( KFalse, "0" );

_LIT (KMPStreamingPauseSupported, "StreamingPauseSupported");

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

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

//  CMPXVideoPlaybackController::NewL()

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

//

CMPXVideoPlaybackController* CMPXVideoPlaybackController::NewL( MMPXPlaybackPluginObserver& aObs )

{

   CMPXVideoPlaybackController* self = new( ELeave ) CMPXVideoPlaybackController();

   CleanupStack::PushL( self );

   self->ConstructL( aObs );

   CleanupStack::Pop();

   return self;

}

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

//  CMPXVideoPlaybackController::CreatePreInitStatesL()

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

//

void CMPXVideoPlaybackController::CreatePreInitStatesL()

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::CreatePreInitStatesL()"));

    iNotIntialisedState = CMPXNotInitialisedState::NewL(this);

    iInitialisingState  = CMPXInitialisingState::NewL(this);

    // Set the default state to non initialised

    iState              = iNotIntialisedState;

}

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

//  CMPXVideoPlaybackController::CreatePostInitStatesL()

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

//

void CMPXVideoPlaybackController::CreatePostInitStatesL()

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::CreatePostInitStatesL()"));

    //

    //  Check if the post init states have been created

    //

    if ( ! iInitialisedState )

    {

        iInitialisedState   = CMPXInitialisedState::NewL(this);

        iPlayingState       = CMPXPlayingState::NewL(this);

        iBufferingState     = CMPXBufferingState::NewL(this);

        iPausedState        = CMPXPausedState::NewL(this);

        iSeekingState       = CMPXSeekingState::NewL(this);

        iStoppedState       = CMPXStoppedState::NewL(this);

    }

}

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

//  CMPXVideoPlaybackController::ConstructL

//  Symbian 2nd phase constructor can leave.

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

//

void CMPXVideoPlaybackController::ConstructL( MMPXPlaybackPluginObserver& aObs )

{

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

    iMPXPluginObs = &aObs;

    iAccessPointId = -1;

    iVideoSeeker = CMPXVideoSeeker::NewL( this );

    // Initiliaze to True

    iSeekable = ETrue;

    InitVolumeWatchers();

    CreatePreInitStatesL();

    iPlayer = CMpxVideoPlayerUtility::NewL( this );

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

    iDrmHelper = CMpxVideoDrmHelper::NewL();

}

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

//  CMPXVideoPlaybackController::CloseController()

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

//

void CMPXVideoPlaybackController::CloseController()

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::CloseController()"));

    ChangeState( EMPXVideoNotInitialized );

}

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

//    CMPXVideoPlaybackController::OpenFileL()

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

//

void CMPXVideoPlaybackController::OpenFileL( const TDesC& aMediaFile,

                                             RFile& aFile,

                                             TInt aAccessPointId )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::OpenFileL()"),

                   _L("file = %S"), &aMediaFile );

    TBool fileExists = EFalse;

    ChangeState( EMPXVideoInitializing );

    iClipName = aMediaFile.AllocL();

    iAccessPointId = aAccessPointId;

    //

    //  If file handle exists, duplicate it to the controller

    //

    if ( aFile.SubSessionHandle() )

    {

        if ( iFileHandle.SubSessionHandle() )

        {

            iFileHandle.Close();

        }

        User::LeaveIfError( iFileHandle.Duplicate( aFile ) );

        fileExists = ETrue;

    }

    DetermineMediaTypeL();

    SetPlaybackModeL();

    //

    //  Create accessory monitor to search for TV-Out events

    //

    if ( ! iAccessoryMonitor )

    {

        iAccessoryMonitor = CMPXVideoAccessoryObserver::NewL( this );

    }

    if ( iAccessoryMonitor->IsTvOutPlaybackAllowed() )

    {

        if ( fileExists )

        {

            //

            //  Ensure there are rights for protected clips

            //

            TInt drmError = iDrmHelper->GetDrmRightsStatus( iFileHandle );

            if ( drmError )

            {

                //

                //  Send error to observer for handling

                //

                HandleError( drmError );

            }

            else

            {

                iState->OpenFileL( iFileHandle );

            }

        }

        else

        {

            iState->OpenFileL( iClipName->Des() );

        }

    }

    else

    {

        HandleError( KMPXVideoTvOutPlaybackNotAllowedClose );

    }

}

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

//    C++ constructor

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

//

CMPXVideoPlaybackController::CMPXVideoPlaybackController()

    : iAppInForeground(ETrue)

    , iForegroundPause(EFalse)

    , iAllowAutoPlay(ETrue)

    , iHelixLoadingStarted(EFalse)

{

}

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

//    Destructor

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

//

CMPXVideoPlaybackController::~CMPXVideoPlaybackController()

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::~CMPXVideoPlaybackController"));

    delete iDrmHelper;

    delete iAccessoryMonitor;

    delete iNotIntialisedState;

    delete iInitialisingState;

    delete iInitialisedState;

    delete iPlayingState;

    delete iBufferingState;

    delete iPausedState;

    delete iSeekingState;

    delete iStoppedState;

    if ( iPlaybackMode )

    {

        delete iPlaybackMode;

        iPlaybackMode = NULL;

    }

    if ( iVolumeWatcher )

    {

        delete iVolumeWatcher;

        iVolumeWatcher = NULL;

    }

    if ( iMuteWatcher )

    {

        delete iMuteWatcher;

        iMuteWatcher = NULL;

    }

    if ( iFileDetails )

    {

        delete iFileDetails;

        iFileDetails = NULL;

    }

    if ( iClipName )

    {

        delete iClipName;

        iClipName = NULL;

    }

    if ( iRecognizedMimeType )

    {

        delete iRecognizedMimeType;

        iRecognizedMimeType = NULL;

    }

    if ( iVideoSeeker )

    {

        delete iVideoSeeker;

        iVideoSeeker = NULL;

    }

    if ( iFileHandle.SubSessionHandle() )

    {

        iFileHandle.Close();

    }

    if ( iBackLightTimer )

    {

        iBackLightTimer->Cancel();

        delete iBackLightTimer;

        iBackLightTimer = NULL;

    }

    if ( iPlayer )

    {

        delete iPlayer;

        iPlayer = NULL;

    }

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    if ( iFileHandle64.SubSessionHandle() )

    {

        iFileHandle64.Close();

    }

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

}

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

//    Executes general playback commands supported by the playback FW

//    CMPXVideoPlaybackController::HandleGeneralPlaybackCommandL()

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

//

void

CMPXVideoPlaybackController::HandleGeneralPlaybackCommandL( CMPXCommand& aCmd )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::HandleGeneralPlaybackTypeL()"));

    if ( aCmd.IsSupported( KMPXCommandPlaybackGeneralType ) )

    {

        TMPXPlaybackCommand cmd = static_cast<TMPXPlaybackCommand>

                                      (aCmd.ValueTObjectL<TInt>(KMPXCommandPlaybackGeneralType ));

        MPX_DEBUG(_L("CMPXVideoPlaybackController::HandleGeneralPlaybackCommandL() id = %d"), cmd );

        DoHandleCommandL( cmd );

    }

}

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

//    Executes general playback commands supported by the playback FW

//    CMPXVideoPlaybackController::HandleCustomPlaybackCommandL()

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

//

void

CMPXVideoPlaybackController::HandleCustomPlaybackCommandL( CMPXCommand& aCmd )

{

    MPX_ENTER_EXIT(

        _L("CMPXVideoPlaybackController::HandleCustomPlaybackCommandL()") );

    if ( aCmd.IsSupported( KMPXMediaVideoPlaybackCommand ) )

    {

        TMPXVideoPlaybackCommand cmd = static_cast<TMPXVideoPlaybackCommand>

                            (aCmd.ValueTObjectL<TInt>(KMPXMediaVideoPlaybackCommand));

        MPX_DEBUG(_L("CMPXVideoPlaybackController::HandleCustomPlaybackCommandL() cmd = %d"), cmd );

        switch ( cmd )

        {

            case EPbCmdInitView:

            {

                if ( iState != iNotIntialisedState)

                {

                    aCmd.SetTextValueL( KMPXMediaVideoPlaybackFileName, *iClipName );

                    aCmd.SetTObjectValueL<TInt>( KMPXMediaVideoMode, iPlaybackMode->GetMode() );

                    aCmd.SetTObjectValueL<TInt>( KMPXMediaVideoTvOutConnected,

                                                 iAccessoryMonitor->IsTvOutConnected() );

                    aCmd.SetTObjectValueL<TInt>( KMPXMediaVideoTvOutPlayAllowed,

                                                 iAccessoryMonitor->IsTvOutPlaybackAllowed() );

                    if ( iRecognizedMimeType )

                    {

                        aCmd.SetTextValueL( KMPXMediaVideoRecognizedMimeType, *iRecognizedMimeType );

                    }

                }

                break;

            }

            case EPbCmdSetDisplayWindow:

            {

                SetDisplayWindowL( aCmd );

                break;

            }

            case EPbCmdAbortDSA:

            {

                AbortDSA();

                break;

            }

            case EPbCmdRestartDSA:

            {

                RestartDSA( aCmd );

                break;

            }

            case EPbCmdStartVideoSeekingForward:

            {

                iState->HandleStartSeekL( ETrue );

                break;

            }

            case EPbCmdStartVideoSeekingBackward:

            {

                iState->HandleStartSeekL( EFalse );

                break;

            }

            case EPbCmdStopVideoSeeking:

            {

                iState->HandleStopSeekL();

                break;

            }

            case EPbCmdHandleForeground:

            {

                iAppInForeground = ETrue;

                iState->HandleForeground();

                break;

            }

            case EPbCmdHandleBackground:

            {

                iAppInForeground = static_cast<TBool>(aCmd.ValueTObjectL<TBool>(KMPXMediaVideoAppForeground));

                iState->HandleBackground();

                break;

            }

            case EPbCmdNaturalAspectRatio:

            {

                iState->SetAspectRatioL( aCmd, EMMFNatural );

                break;

            }

            case EPbCmdZoomAspectRatio:

            {

                iState->SetAspectRatioL( aCmd, EMMFZoom );

                break;

            }

            case EPbCmdStretchAspectRatio:

            {

                iState->SetAspectRatioL( aCmd, EMMFStretch );

                break;

            }

            case EPbCmdUpdateSeekable:

            {

                iSeekable = aCmd.ValueTObjectL<TBool>(KMPXMediaGeneralExtVideoSeekable);

                if( iFileDetails )

                {

                    iFileDetails->iSeekable &= iSeekable;

                }

                break;

            }

            case EPbCmdEndofClipReached:

            {

                iState->HandleEndOfClip();

                break;

            }

            case EPbCmdHandleIncreaseVolume:

            {

                HandleVolumeL( ETrue );

                break;

            }

            case EPbCmdHandleDecreaseVolume:

            {

                HandleVolumeL( EFalse );

                break;

            }

            case EPbCmdCustomPause:

            {

                iState->HandleCustomPause();

                break;

            }

            case EPbCmdCustomPlay:

            {

                iState->HandleCustomPlay();

                break;

            }

            case EPbCmdRetrieveBufferingPercentage:

            {

                TInt bufferingPercentage = 100;

                //

                //  Check if Helix is in the loading state.  If not, return 100 since

                //  Helix believes they are fully loaded

                //

                if ( iHelixLoadingStarted )

                {

                    bufferingPercentage = iState->RetrieveBufferingPercentage();

                }

                aCmd.SetTObjectValueL<TInt>( KMPXMediaVideoBufferingPercentage,

                                             bufferingPercentage );

                break;

            }

            default:

            {

                break;

            }

        }

    }

}