/*

* 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

*

*/

// Version : %version: da1mmcf#43 %

//  Include Files

#include <QTimer>

#include <QGraphicsSceneEvent>

#include <hbmenu.h>

#include <hbaction.h>

#include <hbinstance.h>

#include <hbnotificationdialog.h>

#include <hblabel.h>

#include <hbtapgesture.h>

#include <hbpangesture.h>

#include <textresolver.h>

#include <mmf/common/mmferrors.h>

#include <DRMHelper.h>

#include <mpxvideoplaybackdefs.h>

#include <mpxplaybackcommanddefs.h>

#include <mpxhbvideocommondefs.h>

#include "mpxvideo_debug.h"

#include "mpxvideoviewwrapper.h"

#include "mpxvideoplaybackuids.hrh"

#include "hbvideobaseplaybackview.h"

#include "videoactivitystate.h"   

#include "mpxvideoplaybackviewfiledetails.h"  

#include "mpxcommonvideoplaybackview.hrh"

//  Member Functions

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

// HbVideoBasePlaybackView::HbVideoBasePlaybackView()

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

//

HbVideoBasePlaybackView::HbVideoBasePlaybackView()

    : mVideoMpxWrapper( NULL )

    , mTimerForClosingView( NULL )

    , mActivated( false )

    , mStayPaused ( false )

{

    MPX_ENTER_EXIT(_L("HbVideoBasePlaybackView::HbVideoBasePlaybackView()"));

}

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

//   HbVideoBasePlaybackView::initializeVideoPlaybackView()

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

//

void HbVideoBasePlaybackView::initializeVideoPlaybackView()

{

    MPX_ENTER_EXIT(_L("HbVideoBasePlaybackView::initializeVideoPlaybackView()"));

    //

    // Need to set to control full screen including status pane area

    //

    setContentFullScreen();

    mTimerForClosingView = new QTimer();

    mTimerForClosingView->setSingleShot( true );

    mTimerForClosingView->setInterval( 10 );

    connect( mTimerForClosingView, SIGNAL( timeout() ), this, SIGNAL( activatePreviousView() ) );

    //

    // Read activity data ...

    // If last playback was forced to terminate due to low memory (GOOM, etc.)

    // then the clip needs to be restored to the last played position 

    // and the state needs to be paused, since forced termination can only occur for

    // background apps - so if this happened Video Player must have been in background

    // which implies paused state

    //    

    int lastViewType = VideoActivityState::instance().getActivityData(KEY_VIEWPLUGIN_TYPE).toInt();    

    if ( lastViewType == MpxHbVideoCommon::PlaybackView ) 

    {

        QVariant data = VideoActivityState::instance().getActivityData(KEY_LAST_PLAY_POSITION_ID);

        mLastPlayPosition = data.toInt();   

        mStayPaused = true;

    }     

}

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

// HbVideoBasePlaybackView::~HbVideoBasePlaybackView()

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

//

HbVideoBasePlaybackView::~HbVideoBasePlaybackView()

{

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

    if ( mTimerForClosingView )

    {

        disconnect( mTimerForClosingView, SIGNAL( timeout() ), this, SIGNAL( activatePreviousView() ) );

        if ( mTimerForClosingView->isActive() )

        {

            mTimerForClosingView->stop();

        }

        delete mTimerForClosingView;

        mTimerForClosingView = NULL;

    }

    if ( mVideoMpxWrapper )

    {

        delete mVideoMpxWrapper;

        mVideoMpxWrapper = NULL;

    }

    setParentItem( 0 );

}

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

//   HbVideoBasePlaybackView::handleActivateView()

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

//

void HbVideoBasePlaybackView::handleActivateView()

{

    MPX_ENTER_EXIT(_L("HbVideoBasePlaybackView::handleActivateView()"));

    MPX_TRAPD( err, mVideoMpxWrapper = CMPXVideoViewWrapper::NewL( this ) );

    QCoreApplication::instance()->installEventFilter( this );

    //

    //  Request the needed Media from the Playback Plugin

    //

    MPX_TRAP( err, mVideoMpxWrapper->RequestMediaL() );

    menu()->close();

    //

    // Landscape orientation

    // Workaround: Disable orientation transition effect

	// since orbit couldn't emit the orientationChanged signal with transition effect

	//

    hbInstance->allMainWindows()[0]->setOrientation( Qt::Horizontal, false );

    mActivated = true;

}

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

//   HbVideoBasePlaybackView::handleDeactivateView()

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

//

void HbVideoBasePlaybackView::handleDeactivateView()

{

    MPX_ENTER_EXIT(_L("HbVideoBasePlaybackView::handleDeactivateView()"));

    saveActivityData();

    mActivated = false;

    QCoreApplication::instance()->removeEventFilter( this );

    //

    //  Close the playback plugin to release all references to previous clip

    //

    MPX_TRAPD( err, mVideoMpxWrapper->HandleCommandL( EMPXPbvCmdClose ) );

    if ( mVideoMpxWrapper )

    {

        delete mVideoMpxWrapper;

        mVideoMpxWrapper = NULL;

    }

    //

    // go back to device orientation

    //

    //hbInstance->allMainWindows()[0]->unsetOrientation();

}

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

//   HbVideoBasePlaybackView::saveActivityData()

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

//

void HbVideoBasePlaybackView::saveActivityData()

{

    MPX_DEBUG( _L("HbVideoBasePlaybackView::saveActivityData()") );  

    // save the activity data

    QVariant data = QString( mVideoMpxWrapper->iFileDetails->mClipName );

    VideoActivityState::instance().setActivityData(data, KEY_LAST_PLAYED_CLIP); 

    data = int( mVideoMpxWrapper->iPlayPosition );

    VideoActivityState::instance().setActivityData(data, KEY_LAST_PLAY_POSITION_ID);

    data = bool( mVideoMpxWrapper->iFileDetails->mPlaybackMode == EMPXVideoLocal );

    VideoActivityState::instance().setActivityData(data, KEY_LAST_LOCAL_PLAYBACK);     

}

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

//   HbVideoBasePlaybackView::handleClosePlaybackView()

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

//

void HbVideoBasePlaybackView::handleClosePlaybackView()

{

    MPX_DEBUG(

      _L("HbVideoBasePlaybackView::handleClosePlaybackView()") );

    if ( mVideoMpxWrapper && mVideoMpxWrapper->IsMultiItemPlaylist() )

    {

        TRAP_IGNORE( mVideoMpxWrapper->HandleCommandL( EMPXPbvCmdNextListItem ) );

    }

    else

    {

        closePlaybackView();

    }

}

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

//   HbVideoBasePlaybackView::handlePluginError()

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

//

void HbVideoBasePlaybackView::handlePluginError( int aError )

{

    MPX_DEBUG(

      _L("HbVideoBasePlaybackView::handlePluginError() aError = %d"), aError );

    switch ( aError )

    {

        case KErrCancel:

		{

            handleClosePlaybackView();

            break;

        }

        case KErrMMDRMNotAuthorized:

        case KErrCANoRights:

        case KErrCANoPermission:

        {

            showDialog( hbTrId( "txt_videos_info_license_has_expired_or_it_is_missi" ) );

            break;

        }

        case KMPXVideoCallOngoingError:

        {

            showDialog( hbTrId( "txt_videos_info_video_playback_is_not_allowed_duri" ), false );

            break;

        }

        default:

        {

            TRAP_IGNORE(

                //

                //  TextResolver instance for error resolving.

                //

                CTextResolver* textresolver = CTextResolver::NewLC();

                //

                //  Resolve the error text

                //

                TPtrC text;

                text.Set( textresolver->ResolveErrorString( aError ) );

                //

                // convert to QString

                //

                const QString qString( (QChar*)text.Ptr(), text.Length() );

                //

                // clean up textresolver

                //

                CleanupStack::PopAndDestroy( textresolver );

                //

                // display error and close playback view

                //

                showDialog( qString );

            );

        }

    }

}

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

//   HbVideoBasePlaybackView::showDialog

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

//

void HbVideoBasePlaybackView::showDialog( const QString& qString, bool closeView )

{

    MPX_DEBUG(_L("HbVideoBasePlaybackView::showDialog( %s, %d )"), qString.data(), closeView );

    //

    // create pop-up dialog for error notes,

    //     set its position to the middle of the screen

    //     and make sure pop-up dialog gets deleted on close.

    //

    QRectF screenRect = hbInstance->allMainWindows()[0]->rect();

    HbNotificationDialog* dlg = new HbNotificationDialog();

    dlg->setAttribute( Qt::WA_DeleteOnClose );

    dlg->setMinimumSize( QSizeF(200, 100) );

    dlg->setPreferredPos( QPointF( screenRect.height()/2, screenRect.width()/2 ),

                          HbPopup::Center );

	if ( closeView )

	{

        //

        // connect aboutToClose() signal to handleClosePopupDialog() slot so that

        // when pop-up dialog is closed, playback view is closed also

        //

        connect( dlg, SIGNAL( aboutToClose() ), this, SLOT( handleClosePopupDialog() ) );

    }

    //

    // convert string to label so text alignment can be set

    //

    HbLabel *label = new HbLabel( qString );

    label->setAlignment( Qt::AlignCenter );

    //

    // set label as content widget and show pop-up dialog

    //

    dlg->setContentWidget( label );

    dlg->show();

}

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

//   HbVideoBasePlaybackView::doClosePlayer

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

//

void HbVideoBasePlaybackView::doClosePlayer()

{

    MPX_DEBUG(_L("HbVideoBasePlaybackView::doClosePlayer()"));

    handleDeactivateView();

    qApp->quit();

}

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

//   HbVideoBasePlaybackView::issuePlayCommand

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

//

void HbVideoBasePlaybackView::issuePlayCommand()

{

    MPX_ENTER_EXIT(_L("HbVideoBasePlaybackView::issuePlayCommand()"));

    int err = KErrNone;

    TRAP( err, mVideoMpxWrapper->CreateGeneralPlaybackCommandL( EPbCmdPlay ));

    MPX_DEBUG(_L("HbVideoBasePlaybackView::issuePlayCommand() error = %d"), err);

}

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

//   HbVideoBasePlaybackView::retrievePdlInformation

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

//

void HbVideoBasePlaybackView::retrievePdlInformation()

{

    MPX_DEBUG(_L("HbVideoBasePlaybackView::retrievePdlInformation()"));

}

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

//   HbVideoBasePlaybackView::handleBufferingState

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

//

void HbVideoBasePlaybackView::handleBufferingState()

{

    MPX_DEBUG(_L("HbVideoBasePlaybackView::handleBufferingState()"));

}

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

//   HbVideoBasePlaybackView::closePlaybackView()

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

//

void HbVideoBasePlaybackView::closePlaybackView()

{

    MPX_ENTER_EXIT(_L("HbVideoBasePlaybackView::closePlaybackView()"));

    mTimerForClosingView->start( 0 );

}

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

// HbVideoBasePlaybackView::eventFilter

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

//

bool HbVideoBasePlaybackView::eventFilter( QObject *object, QEvent *event )

{

    Q_UNUSED( object );

    switch ( event->type() )

    {

        case QEvent::ApplicationActivate:

        {

            if ( mActivated )

            {

                MPX_DEBUG(_L("HbVideoBasePlaybackView::eventFilter foreground()") );

                TRAP_IGNORE( mVideoMpxWrapper->IssueVideoAppForegroundCmdL( true ) );

            }

            break;

        }

        case QEvent::ApplicationDeactivate:

        {

            if ( mActivated )

            {

                MPX_DEBUG(_L("HbVideoBasePlaybackView::eventFilter background()") );

                TRAP_IGNORE( mVideoMpxWrapper->IssueVideoAppForegroundCmdL( false ) );

            }

            break;

        }

    }

    return QObject::eventFilter( object, event );

}

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

//   HbVideoBasePlaybackView::getWindow()

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

//

RWindow *HbVideoBasePlaybackView::getWindow()

{

    return static_cast<RWindow*>( hbInstance->allMainWindows()[0]->effectiveWinId()->DrawableWindow() );

}

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

//   HbVideoBasePlaybackView::handleClosePopupDialog()

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

//

void HbVideoBasePlaybackView::handleClosePopupDialog()

{

    MPX_DEBUG(_L("HbVideoBasePlaybackView::handleClosePopupDialog()") );

    handleClosePlaybackView();

}

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

//   HbVideoBasePlaybackView::gestureEvent()

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

//

void HbVideoBasePlaybackView::gestureEvent( QGestureEvent* event )

{

    if ( HbTapGesture * gesture = static_cast<HbTapGesture *>( event->gesture( Qt::TapGesture ) ) )

    {

        if ( gesture->state() == Qt::GestureFinished && mActivated )

        {

            MPX_DEBUG(_L("HbVideoBasePlaybackView::gestureEvent() tapGesture finished") );

            emit tappedOnScreen();

        }

    }

    else if ( HbPanGesture* gesture = static_cast<HbPanGesture*>( event->gesture( Qt::PanGesture ) ) )

    {

        if ( gesture->state() == Qt::GestureFinished && mActivated )

        {

            QPointF delta( gesture->sceneDelta() );

            if ( delta.x() > 0 )

            {

                MPX_DEBUG(_L("HbVideoBasePlaybackView::gestureEvent() right") );

                emit pannedToRight();

            }

            else

            {

                MPX_DEBUG(_L("HbVideoBasePlaybackView::gestureEvent() left") );

                emit pannedToLeft();

            }

        }

    }

}

// EOF