/*

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

*

*/

// 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 "mpxvideoviewwrapper.h"

#include "hbvideobaseplaybackview.h"

#include "mpxvideoplaybackcontrolbar.h"

#include "mpxvideoplaybackcontrolpolicy.h"

#include "mpxvideoplaybackdocumentloader.h"

#include "mpxvideoplaybackviewfiledetails.h"

#include "mpxvideoplaybackstatuspanecontrol.h"

#include "mpxvideoplaybackfiledetailswidget.h"

#include "mpxvideoplaybackfullscreencontrol.h"

#include "mpxvideoplaybackcontrolscontroller.h"

#include "mpxvideoplaybackcontrolconfiguration.h"

#include "mpxvideoplaybackdetailsplaybackwindow.h"

#include "videoservices.h"

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

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

// QMPXVideoPlaybackControlsController::QMPXVideoPlaybackControlsController()

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

//

QMPXVideoPlaybackControlsController::QMPXVideoPlaybackControlsController(

        HbVideoBasePlaybackView *view,

        CMPXVideoViewWrapper *viewWrapper,

        QMPXVideoPlaybackViewFileDetails *details )

    : mView( view )

    , mViewWrapper( viewWrapper )

    , mFileDetails( details )

    , mControlsPolicy( NULL )

    , mControlsConfig( NULL )

    , mControlsTimer( NULL )

    , mLoader( NULL )

    , mVolumeControl( NULL )

    , mThumbnailManager( NULL )

    , mVideoServices( 0 )

    , mViewTransitionIsGoingOn( false )

    , mIsAttachOperation( false )

    , mThumbNailState( EThumbNailEmpty )

    , mState( EPbStateNotInitialised )

    , mViewMode( EFullScreenView )

{

    MPX_ENTER_EXIT(_L("QMPXVideoPlaybackControlsController::QMPXVideoPlaybackControlsController()"));

    initializeController();

}

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

// QMPXVideoPlaybackControlsController::initializeController()

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

//

void QMPXVideoPlaybackControlsController::initializeController()

{

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

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

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

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

    MPX_DEBUG(

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

        mOrientation, ok );

    setParent( mView );

    mView->hideItems( Hb::AllItems );

    //

    // Create layout loader

    //

    ok = false;

    mLoader = new QMPXVideoPlaybackDocumentLoader( this );

    mLoader->load( KMPXPLAYBACKVIEW_XML, &ok );

    if ( ok )

    {

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

        mView->setWidget( widget );

    }

    else

    {

        MPX_DEBUG(

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

        //

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

        //

        delete mLoader;

        mLoader = NULL;

    }

    mControlsTimer = new QTimer( this );

    mControlsTimer->setInterval( KMPXControlsTimeOut );

    mControlsTimer->setSingleShot( false );

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

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

    mControlsPolicy = new QMPXVideoPlaybackControlPolicy();

    mControlsConfig = new QMPXVideoPlaybackControlConfiguration( this );

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

    mControlsConfig->createControlList();

    mVolumeControl = new HbVolumeSliderPopup();

    mVolumeControl->setVisible( false );

    mVolumeControl->setTimeout( KMPXControlsTimeOut );

    mVolumeControl->setTickPosition( Hb::NoSliderTicks );

    mVolumeControl->setRange( KPbPlaybackVolumeLevelMin, KPbPlaybackVolumeLevelMax );

    //

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

            }

        }

    }

}

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

// QMPXVideoPlaybackControlsController::~QMPXVideoPlaybackControlsController

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

//

QMPXVideoPlaybackControlsController::~QMPXVideoPlaybackControlsController()

{

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

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

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

    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 ( 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;

    }

}

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

// QMPXVideoPlaybackControlsController::addFileDetails()

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

//

void QMPXVideoPlaybackControlsController::addFileDetails(

    QMPXVideoPlaybackViewFileDetails* details )

{

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

    mFileDetails = details;

    mControlsConfig->updateControlsWithFileDetails();

    //

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

    //

    if ( ! details->mVideoEnabled )

    {

        changeViewMode( EAudioOnlyView, false );

    }

    if ( details->mTvOutConnected )

    {

        handleEvent( EMPXControlCmdTvOutConnected );

    }

    //

    // Dimmed the volume control if it is video only

    //

    if ( ! mFileDetails->mAudioEnabled )

    {

        mVolumeControl->setValue( 0 );

        mVolumeControl->setEnabled( false );

    }

}

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

// QMPXVideoPlaybackControlsController::handleEvent

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

//

void QMPXVideoPlaybackControlsController::handleEvent(

    TMPXVideoPlaybackControlCommandIds event, int value )

{

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

    switch ( event )

    {

        case EMPXControlCmdSetPosition:

        {

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

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

            break;

        }

        case EMPXControlCmdSetDuration:

        {

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

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

            break;

        }

        case EMPXControlCmdStateChanged:

        {

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

            handleStateChange( (TMPXPlaybackState)value );

            break;

        }

        case EMPXControlCmdSetVolume:

        {

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

            volumeChanged( value );

            break;

        }

        case EMPXControlCmdSetAspectRatio:

        {

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

            aspectRatioChanged( value );

            break;

        }

        case EMPXControlCmdSetDownloadSize:

        {

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

            setDownloadSize( value );

            break;

        }

        case EMPXControlCmdDownloadUpdated:

        {

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

            updateDownloadPosition( value );

            break;

        }

        case EMPXControlCmdDownloadComplete:

        {

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

            updateDownloadPosition( value );

            break;

        }

        case EMPXControlCmdSetDownloadPaused:

        case EMPXControlCmdClearDownloadPaused:

        {

            mControlsConfig->updateControlList( event );

            break;

        }

        case EMPXControlCmdTvOutConnected:

        {

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

            handleTvOutEvent( true, event );

            break;

        }

        case EMPXControlCmdTvOutDisconnected:

        {

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

            handleTvOutEvent( false, event );

            break;

        }

        case EMPXControlCmdHandleErrors:

        {

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

            handleErrors();

            break;

        }

        case EMPXControlCmdShowVolumeControls:

        {

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

            showVolumeControls();

            break;

        }

    }

}

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

// QMPXVideoPlaybackControlsController::handleStateChange

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

//

void QMPXVideoPlaybackControlsController::handleStateChange( TMPXPlaybackState newState )

{

    MPX_ENTER_EXIT(_L("QMPXVideoPlaybackControlsController::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:

            {

                //

                //  Show all the controls

                //

                showControls();

                updateState();

                break;

            }

            default:

            {

                break;    

            }

        }

    }

}

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

// QMPXVideoPlaybackControlsController::controlsListUpdated()

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

//

void QMPXVideoPlaybackControlsController::controlsListUpdated()

{

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

    hideAllControls();

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

    QList<TMPXVideoPlaybackControls> 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.

            //

            myList.removeAt( index );

        }

    }

    //

    //  The updated list will contain added controls only

    //

    for ( int j = 0 ; j < myList.count() ; j++ )

    {

        appendControl( myList[j] );

    }

    for ( int i = 0 ; i < mControls.count() ; i++ )

    {

        mControls[i]->updateControlsWithFileDetails( mFileDetails );

    }

    showControls();

}

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

// QMPXVideoPlaybackControlsController::appendControl()

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

//

void QMPXVideoPlaybackControlsController::appendControl( TMPXVideoPlaybackControls controlIndex )