/*

* Copyright (c) 2009 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 Video base playback view

*

*/

//  Include Files

#include <w32std.h>

#include <eikenv.h>

#include <mpxplaybackcommanddefs.h>

#include <mpxvideoplaybackdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcommand.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessage.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediavideodefs.h>

#include <mpxplaybackutility.h>

#include <mmf/common/mmferrors.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionplaylist.h>

#include <mpxmediageneralextdefs.h>

#include "mpxvideo_debug.h"

#include "mpxvideoregion.h"

#include "mpxvideoviewwrapper.h"

#include "mpxvideoplaybackuids.hrh"

#include "mpxhbvideocommondefs.h"

#include "hbvideobaseplaybackview.h"

#include "mpxvideoplaybackcontrol.hrh"

#include "mpxvideoplaybackviewfiledetails.h"

#include "mpxvideoplaybackdisplayhandler.h"

#include "mpxcommonvideoplaybackview.hrh"

#include "mpxvideoplaybackcontrolscontroller.h"

#include "mpxvideoplaybackuserinputhandler.h"

//  Member Functions

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

// CMPXVideoViewWrapper::CMPXVideoViewWrapper()

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

//

CMPXVideoViewWrapper::CMPXVideoViewWrapper( HbVideoBasePlaybackView* aView )

    : iView( aView )

    , iControlsController( NULL )

    , iMediaRequested( false )

    , iPlaylistView( false )

{

}

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

// CMPXVideoViewWrapper::NewL()

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

//

CMPXVideoViewWrapper* CMPXVideoViewWrapper::NewL( HbVideoBasePlaybackView* aView )

{

    MPX_ENTER_EXIT(_L("CMPXVideoViewWrapper::NewL()"));

    CMPXVideoViewWrapper* self = new (ELeave) CMPXVideoViewWrapper( aView );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

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

//   CMPXVideoViewWrapper::ConstructL()

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

//

void CMPXVideoViewWrapper::ConstructL()

{

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

    iPlaybackUtility = 

        MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    iPlaybackUtility->SetPrimaryClientL();

    //

    //  Create Active Object for closing player

    //

    iCloseAO = CIdle::NewL( CActive::EPriorityStandard );   

    //

    //  Create Video Playback Display Handler

    //

    iDisplayHandler = CMPXVideoPlaybackDisplayHandler::NewL( iPlaybackUtility, this );

    //

    // Create control's controller

    //

    CreateControlsL();

    //

    // Create user input handler

    //

    iUserInputHandler = CMPXVideoPlaybackUserInputHandler::NewL( this, iFileDetails->mTvOutConnected );

}

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

// CMPXVideoViewWrapper::~CMPXVideoViewWrapper()

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

//

CMPXVideoViewWrapper::~CMPXVideoViewWrapper()

{

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

    //

    //  Delete the display handler when the view is deactivated

    //

    if ( iDisplayHandler )

    {

        delete iDisplayHandler;

        iDisplayHandler = NULL;

    }

    if ( iUserInputHandler )

    {

        delete iUserInputHandler;

        iUserInputHandler = NULL;

    }

    if ( iControlsController )

    {

        delete iControlsController;

        iControlsController = NULL;

    }

    if ( iCloseAO )

    {

        delete iCloseAO;

        iCloseAO = NULL;

    }

    if ( iFileDetails )

    {

        delete iFileDetails;

        iFileDetails = NULL;

    }

    if ( iPlaybackUtility )

    {

        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );

        iPlaybackUtility->Close();

        iPlaybackUtility = NULL;

    }

    if ( iCollectionUtility )

    {

        iCollectionUtility->Close();

    }

}

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

// CMPXVideoViewWrapper::IsLive()

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

//

TBool CMPXVideoViewWrapper::IsLive()

{

    return (iFileDetails->mPlaybackMode == EMPXVideoLiveStreaming);

}

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

// CMPXVideoViewWrapper::IsPlaylist()

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

//

TBool CMPXVideoViewWrapper::IsPlaylist()

{

    return iPlaylistView;

}

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

//   CMPXVideoViewWrapper::CreateGeneralPlaybackCommandL()

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

//

void CMPXVideoViewWrapper::CreateGeneralPlaybackCommandL( TMPXPlaybackCommand aCmd )

{

    MPX_DEBUG(_L("CMPXVideoViewWrapper::CreateGeneralPlaybackCommandL(%d)"), aCmd );

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

    cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer, ETrue );

    cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral );

    cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, aCmd );

    iPlaybackUtility->CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );

}

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

//   CMPXVideoViewWrapper::HandleCommandL()

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

//

void CMPXVideoViewWrapper::HandleCommandL( TInt aCommand )

{

    MPX_ENTER_EXIT(

        _L("CMPXVideoViewWrapper::HandleCommandL()"),

        _L("aCommand = %d"), aCommand );

    switch ( aCommand )

    {

        case EMPXPbvCmdPlay:

        {

            IssuePlayCommandL();

            break;

        }

        case EMPXPbvCmdPause:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdPause"));

            CreateGeneralPlaybackCommandL( EPbCmdPause );

            break;

        }

        case EMPXPbvCmdClose:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdClose"));

            CreateGeneralPlaybackCommandL( EPbCmdClose );

            break;

        }

        case EMPXPbvCmdSeekForward:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdSeekForward"));

            CreateVideoSpecificCmdL( EPbCmdStartVideoSeekingForward );

            break;

        }

        case EMPXPbvCmdSeekBackward:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdSeekBackward"));

            CreateVideoSpecificCmdL( EPbCmdStartVideoSeekingBackward );

            break;

        }

        case EMPXPbvCmdEndSeek:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdEndSeek"));

            CreateVideoSpecificCmdL( EPbCmdStopVideoSeeking );

            break;

        }

        case EMPXPbvCmdPlayPause:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdPause"));

            iPlaybackUtility->CommandL( EPbCmdPlayPause );

            break;

        }

        case EMPXPbvCmdStop:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdStop"));

            CreateGeneralPlaybackCommandL( EPbCmdStop );

            break;

        }

        case EMPXPbvCmdDecreaseVolume:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdDecreaseVolume"));

            HandleVolumeCmdL( EPbCmdDecreaseVolume );

            break;

        }

        case EMPXPbvCmdIncreaseVolume:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdIncreaseVolume"));

            HandleVolumeCmdL( EPbCmdIncreaseVolume );

            break;

        }

        case EMPXPbvCmdNaturalAspectRatio:

        {

            MPX_DEBUG(

                _L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdNaturalAspectRatio"));

            SetAspectRatioL( EPbCmdNaturalAspectRatio );

            break;

        }

        case EMPXPbvCmdZoomAspectRatio:

        {

            MPX_DEBUG(

                _L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdZoomAspectRatio"));

            SetAspectRatioL( EPbCmdZoomAspectRatio );

            break;

        }

        case EMPXPbvCmdStretchAspectRatio:

        {

            MPX_DEBUG(

                _L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdStretchAspectRatio"));

            SetAspectRatioL( EPbCmdStretchAspectRatio );

            break;

        }

        case EMPXPbvCmdMute:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdMute"));

            HandleVolumeCmdL( EPbCmdMuteVolume );

            break;

        }

        case EMPXPbvCmdUnMute:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdUnMute"));

            HandleVolumeCmdL( EPbCmdUnMuteVolume );

            break;

        }

        case EMPXPbvCmdShortPressBackward:

        {

            MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() EMPXPbvCmdShortPressBackward"));

            HandleShortPressBackwardL();

            break;

        }

        case EMPXPbvCmdResetControls:

        {

            CreateControlsL();

            iView->retrievePdlInformation();

            break;

        }

        case EMPXPbvCmdNextListItem:

        {

            if ( iPlaylistView && iFileDetails->mMultiItemPlaylist )

            {

                iPlaybackUtility->CommandL( EPbCmdNext );

            }

            break;

        }

        case EMPXPbvCmdPreviousListItem:  

        {

            if ( iPlaylistView && iFileDetails->mMultiItemPlaylist )

            {

			    //

			    // the command is being sent twice on purpose

                // one EMPXPbvCmdPreviousListItem command only sets the position to 0  

                // the second cmd actually goes to the previous item in the list

				//

                iPlaybackUtility->CommandL( EPbCmdPrevious );

                iPlaybackUtility->CommandL( EPbCmdPrevious );  

            }

            break;

        }

        case EMPXPbvCmdEndOfClip:

        {

            CreateVideoSpecificCmdL( EPbCmdEndofClipReached );

            break;

        }

        case EMPXPbvCmdCustomPause:

        {

            CreateVideoSpecificCmdL( EPbCmdCustomPause );

            break;

        }

        case EMPXPbvCmdCustomPlay:

        {

            CreateVideoSpecificCmdL( EPbCmdCustomPlay );

            break;

        }

    }

}

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

// From MMPXPlaybackObserver

// Handle playback message.

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

//

void CMPXVideoViewWrapper::HandlePlaybackMessage( CMPXMessage* aMessage, TInt aError )

{

    MPX_ENTER_EXIT(_L("CMPXVideoViewWrapper::HandlePlaybackMessage()"),

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

    if ( aError )

    {

        MPX_TRAPD( err, DoHandleErrorPlaybackMessageL( aError ) );

    }

    else if ( aMessage )

    {

        MPX_TRAPD( err, DoHandlePlaybackMessageL( aMessage ) );

    }

}

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

// Request for the media object

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

//

void CMPXVideoViewWrapper::RequestMediaL()

{

    MPX_ENTER_EXIT(_L("CMPXVideoViewWrapper::RequestMediaL()"));

    if ( ! iMediaRequested && iPlaybackUtility->StateL() == EPbStateInitialised )

    {

        iMediaRequested = ETrue;

        //

        //  Request the volume for the controls

        //

        iPlaybackUtility->PropertyL( *this, EPbPropertyVolume );

        //

        //  Request the clip's meta data

        //

        MMPXSource* s = iPlaybackUtility->Source();

        if ( s )

        {

            RArray<TMPXAttribute> attrs;

            CleanupClosePushL(attrs);

            //

            //  General Media Attributes

            //

            attrs.Append( KMPXMediaGeneralUri |

                          KMPXMediaGeneralDuration |

                          KMPXMediaGeneralTitle |

                          KMPXMediaGeneralMimeType );

            //

            //  Video specific Attributes

            //

            attrs.Append( KMPXMediaVideoAll );

            // Set the attribute to always route the media call to playback plugin

            CMPXAttributeSpecs* specs = CMPXAttributeSpecs::NewL();

            CleanupStack::PushL( specs );

            specs->SetTObjectValueL<TBool>(KMPXMediaGeneralExtMediaRedirect, ETrue);

            s->MediaL( attrs.Array(), *this, specs);

            CleanupStack::PopAndDestroy( specs );

            CleanupStack::PopAndDestroy( &attrs );

        }

    }

}

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

//   CMPXVideoViewWrapper::DoHandlePlaybackMessageL()

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

//

void CMPXVideoViewWrapper::DoHandlePlaybackMessageL( CMPXMessage* aMessage )

{

    TMPXMessageId id( *(aMessage->Value<TMPXMessageId>(KMPXMessageGeneralId)) );

    MPX_ENTER_EXIT(

        _L("CMPXVideoViewWrapper::DoHandlePlaybackMessageL()"),

        _L("id = 0x%08x"), id );

    if ( KMPXMessageGeneral == id )

    {

        HandleGeneralPlaybackMessageL( aMessage );

    }

    else if ( KMPXMediaIdVideoPlayback == id )

    {

        HandleVideoPlaybackMessage( aMessage );

    }

    else if ( KMPXMediaIdVideoDisplayMessage == id )

    {

        if ( iDisplayHandler )

        {

            iDisplayHandler->HandleVideoDisplayMessageL( aMessage );

        }

    }

}

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

//   CMPXVideoViewWrapper::HandleGeneralPlaybackMessageL()

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

//

void CMPXVideoViewWrapper::HandleGeneralPlaybackMessageL( CMPXMessage* aMessage )

{

    TInt event( *aMessage->Value<TInt>( KMPXMessageGeneralEvent ) );

    TInt type( *aMessage->Value<TInt>( KMPXMessageGeneralType ) );

    TInt data( *aMessage->Value<TInt>( KMPXMessageGeneralData ) );

    MPX_DEBUG(

      _L("CMPXVideoViewWrapper::HandleGeneralPlaybackMessageL() event = %d type = %d  value = %d"),

      event, type, data );

    switch ( event )

    {

        case TMPXPlaybackMessage::EStateChanged:

        {

            DoHandleStateChangeL( type );

            break;

        }

        case TMPXPlaybackMessage::EPropertyChanged:

        {

            TMPXPlaybackProperty property(

                 static_cast<TMPXPlaybackProperty>( type ) );

            HandlePropertyL( property, data, KErrNone );

            break;

        }

        case TMPXPlaybackMessage::EDownloadPositionChanged:

        {

            if ( iControlsController )

            {

                iControlsController->handleEvent( EMPXControlCmdDownloadUpdated, data );

            }

            break;

        }

        case TMPXPlaybackMessage::EDownloadStateChanged:

        {

            break;

        }

        case TMPXPlaybackMessage::ECommandReceived:

        {

            break;

        }

        case TMPXPlaybackMessage::EReachedEndOfPlaylist:

        {

            iView->closePlaybackView();

            break;

        }

        case TMPXPlaybackMessage::ESongChanged:

        {

            break;

        }