/*

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

#include <mpxcollectionplaylist.h>

#include <mpxmediageneralextdefs.h>

#include <vcxmyvideosuids.h>

#include "mpxvideo_debug.h"

#include "mpxvideoregion.h"

#include "mpxvideoviewwrapper.h"

#include "mpxvideoplaybackuids.hrh"

#include "mpxhbvideocommondefs.h"

#include "videobaseplaybackview.h"

#include "videoplaybackcontrol.hrh"

#include "videoplaybackviewfiledetails.h"

#include "videoplaybackdisplayhandler.h"

#include "mpxcommonvideoplaybackview.hrh"

#include "videoplaybackcontrolscontroller.h"

#include "videoplaybackuserinputhandler.h"

//  Member Functions

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

// CMPXVideoViewWrapper::CMPXVideoViewWrapper()

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

//

CMPXVideoViewWrapper::CMPXVideoViewWrapper( VideoBasePlaybackView* aView )

    : iView( aView )

    , iControlsController( NULL )

    , iMediaRequestStatus( MediaNotRequested )

    , iPlaylistView( false )

{

}

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

// CMPXVideoViewWrapper::NewL()

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

//

CMPXVideoViewWrapper* CMPXVideoViewWrapper::NewL( VideoBasePlaybackView* 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()"));

    //

    //  Get an instance of collection utility

    //  Used for the Collection Observer to get the MediaL callbacks

    //

    iCollectionUtility = MMPXCollectionUtility::NewL( this );

    //

    //  Create Active Object for closing player

    //

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

    //

    //  Create Video Playback Display Handler

    //

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

    //

    // Create control's controller

    //

    CreateControlsL();

    //

    // Create user input handler

    //

    iUserInputHandler = CVideoPlaybackUserInputHandler::NewL( this );

}

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

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

//

{

    //

    //  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 ( iFileDetails )

    {

        delete iFileDetails;

        iFileDetails = NULL;

    }

    if ( iPlaybackUtility )

    {

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

    }

    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, TBool aDoSync )

{

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

                   _L("aCmd = %d, aDoSync, = %d"), aCmd, aDoSync );

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

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

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

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

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

    iPlaybackUtility->CommandL( *cmd, this );

    CleanupStack::PopAndDestroy( cmd );

}

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

//   CMPXVideoViewWrapper::HandleCommandL()

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

//

void CMPXVideoViewWrapper::HandleCommandL( TInt aCommand )

{

    MPX_ENTER_EXIT(

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

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

    switch ( aCommand )

    {

        case EMPXPbvCmdPlay:

        {

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

            CreateGeneralPlaybackCommandL( EPbCmdPlay );

            break;

        }

        case EMPXPbvCmdPause:

        {

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

            CreateGeneralPlaybackCommandL( EPbCmdPause );

            break;

        }

        case EMPXPbvCmdClose:

        {

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

            //

            // closing playback view occurs:

            //     - synchronously (mSyncClose=true) for PDL case (when PDL is supported)

            //     - asynchronously (mSyncClose=false) for all other cases

            //

            CreateGeneralPlaybackCommandL( EPbCmdClose, iView->mSyncClose );

            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() EMPXPbvCmdPlayPause"));

            if ( iPlaybackState == EPbStatePlaying )

            {

                CreateGeneralPlaybackCommandL( EPbCmdPause );

            }

            else if ( iPlaybackState == EPbStatePaused )

            {

                CreateGeneralPlaybackCommandL( EPbCmdPlay );

            }

            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:

        {

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

            CreateControlsL();

            iView->retrievePdlInformation();

            break;

        }

        case EMPXPbvCmdNextListItem:

        {

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

            if ( iPlaylistView && iFileDetails->mMultiItemPlaylist )

            {

                CreateGeneralPlaybackCommandL( EPbCmdNext );

            }

            else

            {

                MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() ignore EMPXPbvCmdNextListItem"));

            }

            break;

        }

        case EMPXPbvCmdPreviousListItem:

        {

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

            if ( iPlaylistView && iFileDetails->mMultiItemPlaylist )

            {

                //

				// Need to send sync message to go back to a previous clip

                // regardless of current positoin

				//

                CreateGeneralPlaybackCommandL( EPbCmdPrevious );

            }

            else

            {

                MPX_DEBUG(_L("CMPXVideoViewWrapper::HandleCommandL() ignore EMPXPbvCmdNextListItem"));

            }

            break;

        }

        case EMPXPbvCmdEndOfClip:

        {

            CreateVideoSpecificCmdL( EPbCmdEndofClipReached );

            break;

        }

        case EMPXPbvCmdCustomPause:

        {

            CreateVideoSpecificCmdL( EPbCmdCustomPause );

            break;

        }

        case EMPXPbvCmdCustomPlay:

        {

            CreateVideoSpecificCmdL( EPbCmdCustomPlay );

            break;

        }

        case EMPXPbvCmdRealOneBitmapTimeout:

        {

            IssuePlayCommandL();

            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 ( iMediaRequestStatus == MediaNotRequested &&

         iPlaybackUtility->StateL() == EPbStateInitialised  )

    {

        iMediaRequestStatus = MediaRequested;

        if ( iPlaylistView && IsInMemoryPlugin() )

        {

            // Get the media attributes from the collection plugin

            RequestCollectionMediaL();

        }

        else

        {

            // Get the file details from playback plugin

            RequestPlaybackMediaL();

        }

    }

}

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

//   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 )