/*
* Copyright (c) 2010 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 VideoPlaybackVolumeControl
*
*/

// Version : %version:  1 %


#include <QTimer>
#include <hbvolumesliderpopup.h>

#include "mpxvideo_debug.h"
#include "videoplaybackvolumecontrol.h"
#include "videoplaybackcontrolscontroller.h"

const int KVolumeDragEventTimeOut = 100000;   //set volume maximum 10 times a sec during dragging


// -------------------------------------------------------------------------------------------------
// VideoPlaybackVolumeControl::VideoPlaybackVolumeControl()
// -------------------------------------------------------------------------------------------------
//
VideoPlaybackVolumeControl::VideoPlaybackVolumeControl( VideoPlaybackControlsController* controller )
    : mController( controller )
    , mVolumePopup( NULL )
    , mDraggingHandlerTimer( NULL )
    , mVolume( KPbPlaybackVolumeLevelMin )
    , mVolumeNormalizer( 0 )
    , mMutedByMuteIcon( false )
    , mDragging( false )
{
    MPX_ENTER_EXIT(_L("VideoPlaybackVolumeControl::VideoPlaybackVolumeControl"));
}

// -------------------------------------------------------------------------------------------------
// VideoPlaybackVolumeControl::~VideoPlaybackVolumeControl()
// -------------------------------------------------------------------------------------------------
//
VideoPlaybackVolumeControl::~VideoPlaybackVolumeControl()
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::~VideoPlaybackVolumeControl()"));

    if ( mDraggingHandlerTimer )
    {
        disconnect( mDraggingHandlerTimer, SIGNAL( timeout() ), this, SLOT( handleDraggingTimerTimeOut() ) );

        if ( mDraggingHandlerTimer->isActive() )
        {
            mDraggingHandlerTimer->stop();
        }

        delete mDraggingHandlerTimer;
        mDraggingHandlerTimer = NULL;
    }

    if ( mVolumePopup )
    {
        disconnect( mVolumePopup, SIGNAL( valueChanged( int ) ), this, SLOT( handleSliderValueChanged( int ) ) );
        disconnect( mVolumePopup, SIGNAL( iconClicked() ), this, SLOT( handleMuteIconClicked() ) );
        disconnect( mVolumePopup, SIGNAL( sliderPressed() ), this, SLOT( handleSliderPressed() ) );
        disconnect( mVolumePopup, SIGNAL( sliderReleased() ), this, SLOT( handleSliderReleased() ) );

        delete mVolumePopup;
        mVolumePopup = NULL;
    }
}

// -------------------------------------------------------------------------------------------------
// VideoPlaybackVolumeControl::initialize()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::initialize()
{
    MPX_ENTER_EXIT(_L("VideoPlaybackVolumeControl::initialize()"));

    if ( ! mVolumePopup )
    {
        //
        // Create volume popup control
        //
        mVolumePopup = new HbVolumeSliderPopup();
        mVolumePopup->setVisible( false );
        mVolumePopup->setTimeout( KControlsTimeOut );
        mVolumePopup->setTickPosition( Hb::NoSliderTicks );

        connect( mVolumePopup, SIGNAL( valueChanged( int ) ), this, SLOT( handleSliderValueChanged( int ) ), Qt::QueuedConnection );
        connect( mVolumePopup, SIGNAL( iconClicked() ), this, SLOT( handleMuteIconClicked() ) );
        connect( mVolumePopup, SIGNAL( sliderPressed() ), this, SLOT( handleSliderPressed() ) );
        connect( mVolumePopup, SIGNAL( sliderReleased() ), this, SLOT( handleSliderReleased() ) );

        if ( mController->fileDetails()->mAudioEnabled )
        {
            int volumeSteps = mController->volumeSteps();

            mVolumePopup->setRange( 0, volumeSteps );
            mVolumePopup->setSingleStep( 1 );
            mVolumeNormalizer = ( KPbPlaybackVolumeLevelMax - KPbPlaybackVolumeLevelMin ) / volumeSteps;
            mVolumePopup->setValue( mVolume / mVolumeNormalizer );

            mDraggingHandlerTimer = new QTimer();
            mDraggingHandlerTimer->setSingleShot( false );
            mDraggingHandlerTimer->setInterval( KVolumeDragEventTimeOut );
            connect( mDraggingHandlerTimer, SIGNAL( timeout() ), this, SLOT( handleDraggingTimerTimeOut() ) );
        }
        else
        {
            //
            // Dimmed the volume control if it is video only
            //
            mVolumePopup->setValue( 0 );
            mVolumePopup->setEnabled( false );
        }

    }
}

// -------------------------------------------------------------------------------------------------
// VideoPlaybackVolumeControl::volumeChanged()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::volumeChanged( int volume )
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::volumeChanged() volume = %d"), volume );

    //
    // If we get expected volume from video helix, we don't need to set the volume to volume slider.
    // Or we can stay in infinite loop like this..1->2->3->4->1->2->3->4...
    // Unlike 9.2, mVolumePopup updates UI first and then emit volumechanged signal,
    // so there should be workaround to avoid infinite loop
    // 1. mVolumePopup->setValue( 5 )
    // 2. mVolumePopup emits valueChanged( 5 )
    // 3. set the volume 5 to video helix
    // 4. video helix sends voluemchanged with volume 5
    //
    if ( mExpectedVolList.length() && mExpectedVolList.first() == volume )
    {
        MPX_DEBUG(_L("VideoPlaybackVolumeControl::volumeChanged() mExpectedVolList.first() = %d"),
                mExpectedVolList.first() );

        mExpectedVolList.removeFirst();
    }
    else if ( ! mDragging )
    {
        mVolume = volume;

        if ( mVolumePopup )
        {
            mVolumePopup->setValue( mVolume / mVolumeNormalizer );
            setVisible( true );
        }
    }
}

// -------------------------------------------------------------------------------------------------
// VideoPlaybackVolumeControl::setVisible()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::setVisible( bool visible )
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::setVisible() visibility = %d"), visible );

    //
	// Late init. When we have to show the volume control, we create.
	//
    if ( ! mVolumePopup )
    {
        initialize();
    }

    mVolumePopup->setVisible( visible );
}

// -------------------------------------------------------------------------------------------------
// VideoPlaybackVolumeControl::isVisible()
// -------------------------------------------------------------------------------------------------
//
bool VideoPlaybackVolumeControl::isVisible()
{
    bool visible = false;

    if ( mVolumePopup )
    {
        visible = mVolumePopup->isVisible();
    }

    MPX_DEBUG(_L("VideoPlaybackVolumeControl::isVisible()"), visible );

    return visible;
}

// -------------------------------------------------------------------------------------------------
//   VideoPlaybackVolumeControl::handleSliderValueChanged()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::handleSliderValueChanged( int volume )
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::handleSliderValueChanged() vol = %d"), volume );

    volume *= mVolumeNormalizer;

    //
    // If user is dragging, we won't send all the volumechanged value to video helix
    // since it causes huge traffic and issues with asynchnous calls
    // So we send commands 10 times a sec as we do in 9.2
    //
    if ( mDragging )
    {
        mDraggingVolume = volume;
    }
    else
    {
        setVolume( volume );
    }
}

// -------------------------------------------------------------------------------------------------
//   VideoPlaybackVolumeControl::handleMuteIconClicked()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::handleMuteIconClicked()
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::handleMuteIconClicked()"));

    if ( mVolumePopup->value() )
    {
        mController->handleCommand( EMPXPbvCmdUnMute );
    }
    else
    {
        mMutedByMuteIcon = true;
        mController->handleCommand( EMPXPbvCmdMute );
    }
}

// -------------------------------------------------------------------------------------------------
//   VideoPlaybackVolumeControl::handleSliderPressed()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::handleSliderPressed()
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::handleSliderPressed()"));

    mDragging = true;

    if ( mDraggingHandlerTimer && mDraggingHandlerTimer->isActive() )
    {
        mDraggingHandlerTimer->stop();
    }

    mDraggingHandlerTimer->start( 0 );
}

// -------------------------------------------------------------------------------------------------
//   VideoPlaybackVolumeControl::handleSliderReleased()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::handleSliderReleased()
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::handleSliderReleased()"));

    mDragging = false;

    if ( mDraggingHandlerTimer )
    {
        mDraggingHandlerTimer->stop();
    }

    setVolume( mDraggingVolume );
}

// -------------------------------------------------------------------------------------------------
//   VideoPlaybackVolumeControl::handleDraggingTimerTimeOut()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::handleDraggingTimerTimeOut()
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::handleDraggingTimerTimeOut() mDraggingVolume = %d")
            ,mDraggingVolume );

    if ( mDragging )
    {
        setVolume( mDraggingVolume );
    }
}

// -------------------------------------------------------------------------------------------------
//   VideoPlaybackVolumeControl::setVolume()
// -------------------------------------------------------------------------------------------------
//
void VideoPlaybackVolumeControl::setVolume( int volume )
{
    MPX_DEBUG(_L("VideoPlaybackVolumeControl::setVolume() mVolume = %d, volume = %d")
            , mVolume, volume );

    if ( mVolume != volume )
    {
        mVolume = volume;

        if ( mMutedByMuteIcon && volume == 0 )
        {
            MPX_DEBUG(_L("VideoPlaybackVolumeControl::setVolume() don't need to update volume right after muted"));

            //
            // If this function gets called sincen user tap on mute icon to mute,
            // Then add min value to the expectedlist. playback plugin will send min value to ui.
            //
            mExpectedVolList.append( KPbPlaybackVolumeLevelMin );

            //
            // Don't need to update volume '0' right after muted.
            // If we set '0' to playbackplugin after muted,
            // it won't go back to previous volume with unmuted through media key or remote
            //
            mMutedByMuteIcon = false;
        }
        else
        {
            MPX_DEBUG(_L("VideoPlaybackVolumeControl::setVolume() setvolume = %d"), mVolume );

            mExpectedVolList.append( mVolume );
            mController->handleCommand( EMPXPbvCmdSetVolume, mVolume );
        }
    }
}

//End of file