/*

* 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 <mpxcommandgeneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include "mpxvideoplaybackcontroller.h"

#include "mpxvideoplaybackstate.h"

#include <mpxvideoplaybackdefs.h>

#include <mpxplaybackpluginobserver.h>

#include <mpxmediageneraldefs.h>

#include <mpxcenrepwatcher.h>

#include <mmf/server/mmffile.h>

#include <mmf/common/mmferrors.h>

#include "mpxvideoseeker.h"

#include "mpxvideoplayerutility.h"

#include "mpxmediavideodefs.h"

//

//  CONSTANTS

//

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

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

//    Symbian 2nd phase constructor can leave.

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

//

void CMPXVideoPlaybackState::ConstructL( CMPXVideoPlaybackController* aVideoPlaybackCtlr )

{

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

    iVideoPlaybackCtlr = aVideoPlaybackCtlr;

    iVideoPlaybackCtlr->iPBPluginError = KErrNone;

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

    iFs.ShareProtected();

}

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

//    C++ constructor

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

//

CMPXVideoPlaybackState::CMPXVideoPlaybackState()

{

}

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

//    Destructor

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

//

CMPXVideoPlaybackState::~CMPXVideoPlaybackState()

{

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

    iFs.Close();

}

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

//    CMPXVideoPlaybackState::OpenFileL

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

void CMPXVideoPlaybackState::OpenFileL( const TDesC& /*aMediaFile*/ )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::OpenFileL()"));

}

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

//    CMPXVideoPlaybackState::OpenFileL

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

void CMPXVideoPlaybackState::OpenFileL( const RFile& /*aMediaFile*/ )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::OpenFileL()"));

}

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

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

//    CMPXVideoPlaybackState::OpenFile64L

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

void CMPXVideoPlaybackState::OpenFile64L( const RFile64& /*aMediaFile*/ )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::OpenFile64L( RFile64 )"));

}

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

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

//    CMPXVideoPlaybackState::HandlePlay()

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

void CMPXVideoPlaybackState::HandlePlay()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandlePlay()"));

}

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

//    CMPXVideoPlaybackState::HandlePause()

//

//   @@FP for now we are assuming that Pause is only valid for Playing state

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

void CMPXVideoPlaybackState::HandlePause()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandlePause()"));

}

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

//    CMPXVideoPlaybackState::HandlePlayPause()

//

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

void CMPXVideoPlaybackState::HandlePlayPause()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandlePlayPause()"));

}

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

//    CMPXVideoPlaybackState::HandleStop()

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

void CMPXVideoPlaybackState::HandleStop()

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleStop()"));

}

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

//  CMPXVideoPlaybackState::HandleClose

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

void CMPXVideoPlaybackState::HandleClose()

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleClose()"));

    iVideoPlaybackCtlr->iPlayer->Stop();

    iVideoPlaybackCtlr->CloseController();

    iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPClosed,

                                                          0,

                                                          KErrNone );

}

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

//    CMPXVideoPlaybackState::HandleStartSeekL()

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

void CMPXVideoPlaybackState::HandleStartSeekL( TBool /*aForward*/ )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleStartSeekL()"));

}

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

//    CMPXVideoPlaybackState::HandleStopSeekL()

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

void CMPXVideoPlaybackState::HandleStopSeekL()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleStopSeekL()"));

}

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

//    CMPXVideoPlaybackState::HandleForeground()

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

void CMPXVideoPlaybackState::HandleForeground()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleForeground()"));

}

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

//    CMPXVideoPlaybackState::HandleBackground()

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

void CMPXVideoPlaybackState::HandleBackground()

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleBackground()"));

    // Just pause the plackback

    HandlePause();

}

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

//    CMPXVideoPlaybackState::HandleOpenComplete()

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

void CMPXVideoPlaybackState::HandleOpenComplete( TInt /*aError*/ )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleOpenComplete()"));

}

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

//    CMPXVideoPlaybackState::HandlePrepareComplete()

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

void CMPXVideoPlaybackState::HandlePrepareComplete(TInt /*aError*/)

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandlePrepareComplete()"));

}

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

//    CMPXVideoPlaybackState::HandleLoadingStarted()

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

void CMPXVideoPlaybackState::HandleLoadingStarted()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleLoadingStarted()"));

}

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

//    CMPXVideoPlaybackState::HandleLoadingComplete()

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

void CMPXVideoPlaybackState::HandleLoadingComplete(TInt /*aError*/)

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleLoadingComplete()"));

}

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

//    CMPXVideoPlaybackState::HandlePlaybackComplete()

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

//

void CMPXVideoPlaybackState::HandlePlaybackComplete( TInt aError )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandlePlaybackComplete()"),

                   _L("error = %d"), aError );

    if ( aError == KErrNone )

    {

        iVideoPlaybackCtlr->ChangeState( EMPXVideoStopped );

        iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent(

            MMPXPlaybackPluginObserver::EPPlayComplete,

            0,

            aError );

    }

    else

    {

        //

        //  Notify the view of an error

        //

        MPX_TRAPD( err, SendErrorToViewL( aError ) );

    }

}

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

//    CMPXVideoPlaybackState::HandleEndOfClip()

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

void CMPXVideoPlaybackState::HandleEndOfClip()

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleEndOfClip()"));

    // Stop the player

    iVideoPlaybackCtlr->iPlayer->Stop();

    iVideoPlaybackCtlr->ChangeState( EMPXVideoStopped );

    iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent(

        MMPXPlaybackPluginObserver::EPPlayComplete,

        0,

        KErrNone );

}

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

//    CMPXVideoPlaybackState::HandleVolumeChange()

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

void CMPXVideoPlaybackState::HandleVolumeChange()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleVolumeChange()"));

}

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

//    CMPXVideoPlaybackState::HandleSetPositionL()

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

void CMPXVideoPlaybackState::HandleSetPositionL(TInt /*aValue*/)

{

    MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleSetPositionL()"));

}

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

//    CMPXVideoPlaybackState::RetrieveFileDetailsL

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

TInt CMPXVideoPlaybackState::RetrieveFileDetailsL( const TArray<TMPXAttribute>& aAttrs,

                                                   CMPXMedia* aMedia )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::RetrieveFileDetailsL()"));

    TUint attrG(0);  //  General attributes

    TUint attrV(0);  //  Video attributes

    if (iVideoPlaybackCtlr->iPBPluginError != KErrNone)

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoError ), iVideoPlaybackCtlr->iPBPluginError );

        iVideoPlaybackCtlr->iPBPluginError = KErrNone;

    }

    else

    {

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

        {

            TMPXAttribute attr( aAttrs[i] );

            if ( attr.ContentId() == KMPXMediaIdGeneral )

            {

                attrG |= attr.AttributeId();

            }

            else if ( attr.ContentId() == KMPXMediaIdVideo )

            {

                attrV |= attr.AttributeId();

            }

        }

        RetrieveGeneralAttributesL( aMedia, attrG );

        RetrieveVideoAttributesL( aMedia, attrV );

    }

    return KErrNone;

}

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

//    CMPXVideoPlaybackState::RetrieveGeneralAttributesL

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

//

void CMPXVideoPlaybackState::RetrieveGeneralAttributesL(  CMPXMedia* aMedia, TUint attrG  )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::RetrieveGeneralAttributesL()"));

    //

    //  Clip name include path excluding scheme

    //

    if ( attrG & EMPXMediaGeneralUri )

    {

        aMedia->SetTextValueL(

            TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralUri ),

            *( iVideoPlaybackCtlr->iFileDetails->iClipName ) );

    }

    //

    //  Duration

    //

    if ( attrG & EMPXMediaGeneralDuration )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralDuration ),

            iVideoPlaybackCtlr->iFileDetails->iDuration.Int64() / KPbMilliMultiplier);

    }

    //

    //  Title

    //

    if ( ( attrG & EMPXMediaGeneralTitle ) && iVideoPlaybackCtlr->iFileDetails->iTitle )

    {

        aMedia->SetTextValueL(

            TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralTitle ),

            *( iVideoPlaybackCtlr->iFileDetails->iTitle ) );

    }

    //

    //  Mime Type

    //

    if ( ( attrG & EMPXMediaGeneralMimeType ) && iVideoPlaybackCtlr->iFileDetails->iMimeType )

    {

         aMedia->SetTextValueL(

             TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralMimeType ),

             *( iVideoPlaybackCtlr->iFileDetails->iMimeType ) );

    }

}

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

//    CMPXVideoPlaybackState::RetrieveVideoAttributesL

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

//

void CMPXVideoPlaybackState::RetrieveVideoAttributesL(  CMPXMedia* aMedia, TUint attrV  )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::RetrieveVideoAttributesL()"));

    //

    //  Artist

    //

    if ( ( attrV & KMPXMediaVideoArtist.iAttributeId ) &&

         ( iVideoPlaybackCtlr->iFileDetails->iArtist ) )

    {

        aMedia->SetTextValueL(

            TMPXAttribute( KMPXMediaVideoArtist ),

            *( iVideoPlaybackCtlr->iFileDetails->iArtist ) );

    }

    //

    //  Partial Playback

    //

    if ( attrV & KMPXMediaVideoPartialPlayback.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoPartialPlayback ),

            iVideoPlaybackCtlr->iFileDetails->iPartialPlayback );

    }

    //

    //  Audio Enabled

    //

    if ( attrV & KMPXMediaVideoAudioEnabled.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoAudioEnabled ),

            iVideoPlaybackCtlr->iFileDetails->iAudioEnabled );

    }

    //

    //  Video Enabled

    //

    if ( attrV & KMPXMediaVideoVideoEnabled.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoVideoEnabled ),

            iVideoPlaybackCtlr->iFileDetails->iVideoEnabled );

    }

    //

    //  Playback Mode

    //

    if ( attrV & KMPXMediaVideoPlaybackMode.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoPlaybackMode ),

            iVideoPlaybackCtlr->iPlaybackMode->GetMode() );

    }

    //

    //  Seekable

    //

    if ( attrV & KMPXMediaVideoSeekable.iAttributeId )

    {

        aMedia->SetTObjectValueL<TBool>(

            TMPXAttribute( KMPXMediaVideoSeekable ),

            iVideoPlaybackCtlr->iFileDetails->iSeekable );

    }

    //

    //  Pausable

    //

    if ( attrV & KMPXMediaVideoPausableStream.iAttributeId )

    {

        aMedia->SetTObjectValueL<TBool>(

            TMPXAttribute( KMPXMediaVideoPausableStream ),

            iVideoPlaybackCtlr->iFileDetails->iPausableStream );

    }

    //

    //  Video Height

    //

    if ( attrV & KMPXMediaVideoHeight.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoHeight ),

            iVideoPlaybackCtlr->iFileDetails->iResolutionHeight );

    }

    //

    //  Video Width

    //

    if ( attrV & KMPXMediaVideoWidth.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoWidth ),

            iVideoPlaybackCtlr->iFileDetails->iResolutionWidth );

    }

    //

    //  TV-Out Connected

    //

    if ( attrV & KMPXMediaVideoTvOutConnected.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoTvOutConnected ),

            iVideoPlaybackCtlr->iAccessoryMonitor->IsTvOutConnected() );

    }

    //

    //  TV-Out Playback Allowed

    //

    if ( attrV & KMPXMediaVideoTvOutPlayAllowed.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoTvOutPlayAllowed ),

            iVideoPlaybackCtlr->iAccessoryMonitor->IsTvOutPlaybackAllowed() );

    }

    //

    //  BitRate

    //

    if ( attrV & KMPXMediaVideoBitRate.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoBitRate ),

            iVideoPlaybackCtlr->iFileDetails->iBitRate );

    }

    //

    //  FourCC Code

    //

    if ( attrV & KMPXMediaFourCCCode.iAttributeId )

    {

        aMedia->SetTObjectValueL<TUint32>(

            TMPXAttribute( KMPXMediaFourCCCode ),

            iVideoPlaybackCtlr->iFileDetails->iFourCCCode );

    }

    //

    //  Drm Protected

    //

    if ( attrV & KMPXMediaVideoDrmProtected.iAttributeId )

    {

        aMedia->SetTObjectValueL<TInt>(

            TMPXAttribute( KMPXMediaVideoDrmProtected ),

            iVideoPlaybackCtlr->iFileDetails->iDrmProtected );

    }