/*

* 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 VideoPlaybackControlsController

*

*/

// Version : %version: da1mmcf#50 %

// INCLUDE FILES

#include <coecntrl.h>

#include <bautils.h>

#include <barsread.h>

#include <f32file.h>

#include <QTimer>

#include <thumbnailmanager_qt.h>

#include <xqserviceutil.h>

#include <hblabel.h>

#include <hbvolumesliderpopup.h>

#include <hbtransparentwindow.h>

#include <hbiconanimationmanager.h>

#include <shareui.h>

#include <hbinstance.h>

#include <hbtapgesture.h>

#include <hbpangesture.h>

#include "mpxvideoviewwrapper.h"

#include "videobaseplaybackview.h"

#include "videoplaybackcontrolbar.h"

#include "videoplaybackcontrolpolicy.h"

#include "videoplaybackdocumentloader.h"

#include "videoplaybackviewfiledetails.h"

#include "videoplaybackstatuspanecontrol.h"

#include "videoplaybackfiledetailswidget.h"

#include "videoplaybackfullscreencontrol.h"

#include "videoplaybackcontrolscontroller.h"

#include "videoplaybackcontrolconfiguration.h"

#include "videoplaybackdetailsplaybackwindow.h"

#include "videoservices.h"

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

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

// VideoPlaybackControlsController::VideoPlaybackControlsController()

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

//

VideoPlaybackControlsController::VideoPlaybackControlsController(

        VideoBasePlaybackView *view,

        CMPXVideoViewWrapper *viewWrapper,

        VideoPlaybackViewFileDetails *details )

    : mView( view )

    , mViewWrapper( viewWrapper )

    , mFileDetails( details )

    , mControlsPolicy( NULL )

    , mControlsConfig( NULL )

    , mControlsTimer( NULL )

    , mRNLogoTimer( NULL )

    , mLoader( NULL )

    , mVolumeControl( NULL )

    , mThumbnailManager( NULL )

    , mVideoServices( 0 )

    , mViewTransitionIsGoingOn( false )

    , mIsAttachOperation( false )

    , mFileDetailsAdded( false )

    , mThumbNailState( EThumbNailEmpty )

    , mState( EPbStateNotInitialised )

    , mViewMode( EFullScreenView )

{

    MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::VideoPlaybackControlsController()"));

    initializeController();

}

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

// VideoPlaybackControlsController::initializeController()

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

//

void VideoPlaybackControlsController::initializeController()

{

    MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::initializeController()"));

    mOrientation = hbInstance->allMainWindows()[0]->orientation();

    bool ok = connect( hbInstance->allMainWindows()[0], SIGNAL( orientationChanged( Qt::Orientation ) ),

                       this, SLOT( handleOrientationChanged( Qt::Orientation ) ) );

    MPX_DEBUG(

        _L("VideoPlaybackControlsController::initializeController() orientation = %d, ok =%d"),

        mOrientation, ok );

    setParent( mView );

    mView->hideItems( Hb::AllItems );

    //

    // Create layout loader

    //

    ok = false;

    mLoader = new VideoPlaybackDocumentLoader( this );

    mLoader->load( KPLAYBACKVIEW_DOCML, &ok );

    if ( ok )

    {

        QGraphicsWidget *widget = mLoader->findWidget( QString( "content" ) );

        mView->setWidget( widget );

    }

    else

    {

        MPX_DEBUG(

                _L("VideoPlaybackControlsController::initializeController()- can't find xml"));

        //

        // Can't find xml for layout. Delete mLoader

        //

        delete mLoader;

        mLoader = NULL;

    }

    mFileDetails->mRNFormat = realFormat( mFileDetails->mClipName );

    //

    // Controls dismissing timer

    //

    mControlsTimer = new QTimer( this );

    mControlsTimer->setInterval( KControlsTimeOut );

    mControlsTimer->setSingleShot( false );

    connect( mControlsTimer, SIGNAL( timeout() ), this, SLOT( hideAllControls() ) );

    mControlsPolicy = new VideoPlaybackControlPolicy();

    mControlsConfig = new VideoPlaybackControlConfiguration( this );

    connect( mControlsConfig, SIGNAL( controlListUpdated() ), this, SLOT( controlsListUpdated() ) );

    mControlsConfig->createControlList();

    //

    // Create volume popup control

    //

    mVolumeControl = new HbVolumeSliderPopup();

    mVolumeControl->setVisible( false );

    mVolumeControl->setTimeout( KControlsTimeOut );

    mVolumeControl->setTickPosition( Hb::NoSliderTicks );

    mVolumeControl->setRange( KPbPlaybackVolumeLevelMin, KPbPlaybackVolumeLevelMax );

    //

    // grab tap gesture

    //

    mView->grabGesture( Qt::TapGesture );

    connect( mView, SIGNAL( tappedOnScreen() ), this, SLOT( handleTappedOnScreen() ) );

    //

    // if videoplayback is in service mode, create a videoservices instance

    //

    if ( XQServiceUtil::isService() && ! mVideoServices )

    {

        //

        // obtain VideoServices instance

        //

        mVideoServices = VideoServices::instance();

        //

        // allow 'attach' operation only for non-streaming media clips

        //

        if ( mVideoServices && mFileDetails->mPlaybackMode == EMPXVideoLocal )

        {

            //

            // determine if this is 'attach' operation

            //

            mIsAttachOperation = ( mVideoServices->currentService() == VideoServices::EUriFetcher );

            if ( mIsAttachOperation )

            {

                //

                // connect signal filePath() to videoservices slot itemSelected()

                //

                connect( this, SIGNAL( attachVideoPath( const QString& ) ),

                         mVideoServices, SLOT( itemSelected( const QString& ) ) );

            }

        }

    }

}

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

// VideoPlaybackControlsController::~VideoPlaybackControlsController

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

//

VideoPlaybackControlsController::~VideoPlaybackControlsController()

{

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

    mView->ungrabGesture( Qt::TapGesture );

    disconnect( mView, SIGNAL( tappedOnScreen() ), this, SLOT( handleTappedOnScreen() ) );

    if ( mFileDetails->mMultiItemPlaylist && mFileDetails->mSeekable )

    {

        mView->ungrabGesture( Qt::PanGesture );

        disconnect( mView, SIGNAL( pannedToRight() ), this, SLOT( skipToNextVideoItem() ) );

        disconnect( mView, SIGNAL( pannedToLeft() ), this, SLOT( skipToPreviousVideoItem() ) );

    }

    disconnect( mControlsConfig, SIGNAL( controlListUpdated() ), this, SLOT( controlsListUpdated() ) );

    disconnect( mControlsTimer, SIGNAL( timeout() ), this, SLOT( hideAllControls() ) );

    disconnect( hbInstance->allMainWindows()[0], SIGNAL( orientationChanged( Qt::Orientation ) ),

                this, SLOT( handleOrientationChanged( Qt::Orientation ) ) );

    mView->setWidget( NULL );

    mControls.clear();

    if ( mControlsTimer )

    {

        delete mControlsTimer;

        mControlsTimer = NULL;

    }

    if ( mRNLogoTimer )

    {

        disconnect( mRNLogoTimer, SIGNAL( timeout() ), this, SLOT( handleRNLogoTimeout() ) );

        delete mRNLogoTimer;

        mRNLogoTimer = NULL;

    }

    if ( mControlsPolicy )

    {

        delete mControlsPolicy;

        mControlsPolicy = NULL;

    }

    if ( mControlsConfig )

    {

        delete mControlsConfig;

        mControlsConfig = NULL;

    }

    if ( mLoader )

    {

        delete mLoader;

        mLoader = NULL;

    }

    if ( mThumbnailManager )

    {

        delete mThumbnailManager;

        mThumbnailManager = NULL;

    }

    if ( mVolumeControl )

    {

        delete mVolumeControl;

        mVolumeControl = NULL;

    }

    if ( mIsAttachOperation )

    {

        //

        // disable connection for 'attach' operation

        //

        disconnect( this, SIGNAL( attachVideoPath( const QString& ) ),

                    mVideoServices, SLOT( itemSelected( const QString& ) ) );

    }

    if ( mVideoServices )

    {

        //

        // decrease videoservices instance count

        //

    	mVideoServices->decreaseReferenceCount();

    	mVideoServices = 0;

    }

}

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

// VideoPlaybackControlsController::addFileDetails()

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

//

void VideoPlaybackControlsController::addFileDetails(

    VideoPlaybackViewFileDetails* details )

{

    MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::addFileDetails"));

    mFileDetailsAdded = true;

    mFileDetails = details;

    mFileDetails->mRNFormat = realFormat( mFileDetails->mClipName );

    mControlsConfig->updateControlsWithFileDetails();

    //

    // for audio-only clips and tv-out, default view is flip view

    //

    if ( ! details->mVideoEnabled )

    {

        changeViewMode( EAudioOnlyView, false );

    }

    if ( details->mTvOutConnected )

    {

        handleEvent( EControlCmdTvOutConnected );

    }

    //

    // Dimmed the volume control if it is video only

    //

    if ( ! mFileDetails->mAudioEnabled )

    {

        mVolumeControl->setValue( 0 );

        mVolumeControl->setEnabled( false );

    }

    //

    // grab pan gesture for playlist and seekable(skippable) clip

    //

    if ( mFileDetails->mMultiItemPlaylist && mFileDetails->mSeekable )

    {

        mView->grabGesture( Qt::PanGesture );

        connect( mView, SIGNAL( pannedToRight() ), this, SLOT( skipToPreviousVideoItem() ) );

        connect( mView, SIGNAL( pannedToLeft() ), this, SLOT( skipToNextVideoItem() ) );

    }

}

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

// VideoPlaybackControlsController::handleEvent

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

//

void VideoPlaybackControlsController::handleEvent(

    TVideoPlaybackControlCommandIds event, int value )

{

    MPX_DEBUG(_L("VideoPlaybackControlsController::handleEvent(%d)"), event);

    switch ( event )

    {

        case EControlCmdSetPosition:

        {

            MPX_DEBUG(_L("    [EControlCmdSetPosition [%d]]"), value );

            positionChanged( (qreal)value / (qreal)KPbMilliMultiplier);

            break;

        }

        case EControlCmdSetDuration:

        {

            MPX_DEBUG(_L("    [EControlCmdSetDuration [%d]]"), value );

            durationChanged( (qreal)value / (qreal)KPbMilliMultiplier );

            break;

        }

        case EControlCmdStateChanged:

        {

            MPX_DEBUG(_L("    [EControlCmdStateChanged]"));

            handleStateChange( (TMPXPlaybackState)value );

            break;

        }

        case EControlCmdSetVolume:

        {

            MPX_DEBUG(_L("    [EControlCmdSetVolume [%d]]"), value );

            volumeChanged( value );

            break;

        }

        case EControlCmdSetAspectRatio:

        {

            MPX_DEBUG(_L("    [EControlCmdSetAspectRatio %d]"), value );

            aspectRatioChanged( value );

            break;

        }

        case EControlCmdSetDownloadSize:

        {

            MPX_DEBUG(_L("    [EControlCmdSetDownloadSize [%d]]"), value );

            setDownloadSize( value );

            break;

        }

        case EControlCmdDownloadUpdated:

        {

            MPX_DEBUG(_L("    [EControlCmdDownloadUpdated [%d]]"), value );

            updateDownloadPosition( value );

            break;

        }

        case EControlCmdDownloadComplete:

        {

            MPX_DEBUG(_L("    [EControlCmdDownloadComplete [%d]]"), value);

            updateDownloadPosition( value );

            break;

        }

        case EControlCmdSurfaceAttached:

        case EControlCmdSurfaceDetached:

        case EControlCmdSetDownloadPaused:

        case EControlCmdClearDownloadPaused:

        {

            mControlsConfig->updateControlList( event );

            break;

        }

        case EControlCmdTvOutConnected:

        {

            MPX_DEBUG(_L("    [EControlCmdTvOutConnected]"));

            handleTvOutEvent( true, event );

            break;

        }

        case EControlCmdTvOutDisconnected:

        {

            MPX_DEBUG(_L("    [EControlCmdTvOutDisConnected]"));

            handleTvOutEvent( false, event );

            break;

        }

        case EControlCmdHandleErrors:

        {

            MPX_DEBUG(_L("    [EControlCmdHandleErrors]"));

            handleErrors();

            break;

        }

        case EControlCmdShowVolumeControls:

        {

            MPX_DEBUG(_L("    [EControlCmdShowVolumeControls]"));

            showVolumeControls();

            break;

        }

    }

}

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

// VideoPlaybackControlsController::handleStateChange

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

//

void VideoPlaybackControlsController::handleStateChange( TMPXPlaybackState newState )

{

    MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::handleStateChange()"),

                   _L("new state = %d"), newState );

    //

    // Somehow EPbStatePlaying, EPbStatePaused gets called twice continously

    //

    if ( newState != mState )

    {

        mState = newState;

        switch ( newState )

        {

            case EPbStatePlaying:

            case EPbStateInitialising:

            case EPbStateBuffering:

            case EPbStatePaused:

            case EPbStateNotInitialised:

            case EPbStatePluginSeeking:

            {

                //

                //  Show all the controls

                //

                showControls();

                updateState();

                break;

            }

            default:

            {

                break;

            }

        }

    }

}

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

// VideoPlaybackControlsController::controlsListUpdated()

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

//

void VideoPlaybackControlsController::controlsListUpdated()

{

    MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::controlsListUpdated()"));

    hideAllControls();

    QList<TVideoPlaybackControls>& updatedList = mControlsConfig->controlList();

    QList<TVideoPlaybackControls> myList = updatedList;

    int controlCount = mControls.count();

    int i = 0 ;

    int index = KErrNotFound;

    for ( int iCnt = 0 ; iCnt < controlCount ; iCnt++ )

    {

        index = myList.indexOf( mControls[i]->controlIndex() );

        if ( index == KErrNotFound )

        {

            //

            //  Delete control since it doesn't exist in new list

            //

            mControls.removeAt( i );

        }

        else

        {

            //

            //  Control exists in new list.

            //  Update the policy property based on file details and view mode to the controls

            //

            TUint properties = 0;

            mControlsPolicy->setControlProperties(

                    mControls[i]->controlIndex(), properties, mFileDetails, mViewMode );

            mControls[i]->updateControlProperties( properties );

            //

            //  Control exists in new list.

            //