/**

* 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:   tester for methods in Video Playback Controls Controller

*

*/

// Version : %version:  13 %

#include <e32err.h>

#include <w32std.h>

#include <qobject>

#include <hbapplication.h>

#include <hbinstance.h>

#include <hblabel.h>

#include <MMFScalingCustomCommandConstants.h>

#include "mpxvideo_debug.h"

#include "videoplaybackcontrol.hrh"

#include "mpxcommonvideoplaybackview.hrh"

#include "testcontrolscontroller.h"

#include "videobaseplaybackview.h"

#include "videoplaybackviewfiledetails.h"

#include "mpxvideoviewwrapper.h"

#include "videoplaybackfullscreencontrol.h"

#include "videoplaybackcontrolconfiguration.h"

#include "thumbnailmanager_qt.h"

#include "videoplaybackdocumentloader.h"

#include "hbvolumesliderpopup.h"

#include "videoservices.h"

#include "xqserviceutilxtra.h"

#define private public

#include "videoplaybackcontrolscontroller.h"

#undef private

const TInt KControlListsUpdated = 12; // additional extension of TMPXPlaybackState

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

// main

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

//

int main(int argc, char *argv[])

{

    HbApplication app(argc, argv);

    HbMainWindow window;

    TestControlsController tv;

    char *pass[3];

    pass[0] = argv[0];

    pass[1] = "-o";

    pass[2] = "c:\\data\\testcontrolscontroller.txt";

    int res = QTest::qExec(&tv, 3, pass);

    return res;

}

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

// init

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

//

void TestControlsController::init()

{

    MPX_ENTER_EXIT(_L("TestControlsController::init()"));

    mBaseVideoView = new VideoBasePlaybackView();

    if ( ! mFileDetails )

    {

        mFileDetails   = new VideoPlaybackViewFileDetails();

    }

    mViewWrapper   = CMPXVideoViewWrapper::NewL( mBaseVideoView );

    mController    = new VideoPlaybackControlsController( mBaseVideoView,

                                                          mViewWrapper,

                                                          mFileDetails );

}

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

// cleanup

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

//

void TestControlsController::cleanup()

{

    MPX_ENTER_EXIT(_L("TestControlsController::cleanup()"));

    delete mController;

    mController = NULL;

    delete mFileDetails;

    mFileDetails = NULL;

    delete mViewWrapper;

    mViewWrapper = NULL;

    delete mBaseVideoView;

    mBaseVideoView = NULL;

}

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

// TestControlsController::testAddFileDetails

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

//

void TestControlsController::testAddFileDetails()

{

    MPX_DEBUG(_L("TestControlsController::testAddFileDetails()") );

    //

    // local real media with no video

    //

    mFileDetails = new VideoPlaybackViewFileDetails();

    mFileDetails->mClipName = QString( "testClip.rm" );

    mFileDetails->mMimeType = QString( "video/x-pn-realvideo" );

    init();

    mController->addFileDetails( mFileDetails );

    QVERIFY( mController->mFileDetails->mRNFormat == true );

    QVERIFY( mController->mViewMode == EAudioOnlyView );

    QVERIFY( mController->mControlsConfig->mUpdateControlsWithFileDetails == true );

    QVERIFY( mController->mControlsConfig->mState == EControlCmdTvOutConnected );

    cleanup();

    //

    // local 3GPP media with video-only

    //

    mFileDetails = new VideoPlaybackViewFileDetails();

    mFileDetails->mClipName = QString("testClip.3gp");

    mFileDetails->mMimeType = QString("video/3gpp");

    mFileDetails->mVideoEnabled = true;

    mFileDetails->mTvOutConnected = true;

    init();

    mController->mViewMode = EFullScreenView;

    QFileInfo videoOnlyFile( mFileDetails->mClipName );

    mController->addFileDetails( mFileDetails );

    QVERIFY( mController->mFileDetails->mRNFormat == false );

    QVERIFY( mController->mControlsConfig->mUpdateControlsWithFileDetails == true );

    //

    // validate 'TvOutConnected'

    //

    verifyHandleEventTvOutResult(true, true);

    //

    // video-only, validate volume control is dimmed

    //

    QVERIFY( mController->mVolumeControl->mValue == 0 );

    QVERIFY( mController->mVolumeControl->isEnabled() == false );

    //

    // verify 'title' (via mClipName) is set properly

    //

    for ( int i=0 ; i < mController->mLoader->mWidgets.count() ; i++ )

    {

        if( mController->mLoader->mWidgets[i]->objectName() ==  QString( "title" ) )

        {

            HbLabel *titleLabel = qobject_cast<HbLabel*>( mController->mLoader->mWidgets[i] );

            QVERIFY( titleLabel->plainText() == videoOnlyFile.baseName() );

            break;

        }

    }

    cleanup();

    //

    // non-local audio-video media, TvOut is not connected

    //

    mFileDetails = new VideoPlaybackViewFileDetails();

    mFileDetails->mClipName = QString("rtsp:://www.youtube.com/testClip.rm");

    mFileDetails->mPlaybackMode = EMPXVideoStreaming;

    mFileDetails->mTvOutConnected = false;

    mFileDetails->mAudioEnabled = true;

    mFileDetails->mTitle = QString("Clip Title");

    init();

    mController->addFileDetails( mFileDetails );

    QVERIFY( mController->mFileDetails->mRNFormat == true );

    QVERIFY( mController->mControlsConfig->mUpdateControlsWithFileDetails == true );

    //

    // verify 'title' (via mTitle) is set properly

    //

    for ( int i=0 ; i < mController->mLoader->mWidgets.count() ; i++ )

    {

        if( mController->mLoader->mWidgets[i]->objectName() ==  QString( "title" ) )

        {

            HbLabel *titleLabel = qobject_cast<HbLabel*>( mController->mLoader->mWidgets[i] );

            QVERIFY( titleLabel->plainText() == mFileDetails->mTitle );

            break;

        }

    }

    cleanup();

}

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

// TestControlsController::testHandleEventSetPosition

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

//

void TestControlsController::testHandleEventSetPosition()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventSetPosition()"));

    init();

    int value = 20000;

    mController->handleEvent( EControlCmdSetPosition, value );

    QVERIFY( mController->mControls[0]->mPosition == ( value / KPbMilliMultiplier ) );

    cleanup();

}

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

// TestControlsController::testHandleEventSetDuration

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

//

void TestControlsController::testHandleEventSetDuration()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventSetDuration()"));

    init();

    int value = 30000;

    mController->handleEvent( EControlCmdSetDuration, value );

    QVERIFY( mController->mControls[0]->mDuration == ( value / KPbMilliMultiplier ) );

    cleanup();

}

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

// TestControlsController::testHandleEventStateChanged

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

//

void TestControlsController::testHandleEventStateChanged()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventStateChanged()"));

    init();

    TVideoPlaybackControlCommandIds event = EControlCmdStateChanged;

    mController->mOrientation = Qt::Horizontal;

    //

    // state change (EPbStateInitialising)

    //

    int value = EPbStateInitialising;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateBuffering)

    //

    value = EPbStateBuffering;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStatePlaying)

    //

    value = EPbStatePlaying;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStatePaused)

    //

    value = EPbStatePaused;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateNotInitialised)

    //

    value = EPbStateNotInitialised;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateStopped)

    //

    value = EPbStateStopped;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateSeekingForward)

    //

    value = EPbStateSeekingForward;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateSeekingBackward)

    //

    value = EPbStateSeekingBackward;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateShuttingDown)

    //

    value = EPbStateShuttingDown;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateDownloading)

    //

    value = EPbStateDownloading;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStatePluginSeeking)

    //

    value = EPbStatePluginSeeking;

    mController->handleEvent( event, value );

    verifyHandleEventStateChangedResult( value );

    cleanup();

}

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

// TestControlsController::verifyHandleEventStateChangedResult

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

//

void TestControlsController::verifyHandleEventStateChangedResult( int value )

{

    MPX_DEBUG(_L("TestControlsController::verifyHandleEventStateChangedResult()"));

    mController->mOrientation = Qt::Horizontal;

    if ( value == EPbStateInitialised &&

            ( mController->mFileDetails->mPlaybackMode == EMPXVideoStreaming ||

              mController->mFileDetails->mPlaybackMode == EMPXVideoLiveStreaming ) )

    {

        QVERIFY( mController->mControlsConfig->mState == EControlCmdPluginInitialized );

    }

    else if ( value == EPbStatePlaying || value == EPbStateInitialising ||

              value == EPbStateBuffering || value == EPbStatePaused ||

              value == EPbStateNotInitialised )

    {

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

        {

            QVERIFY( mController->mControls[i]->mState == value );

            QVERIFY( mController->mControls[i]->mVisibilityState == value );

        }

    }

    else

    {

        QVERIFY( mController->mState == value );

    }

}

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

// TestControlsController::testHandleEventSetVolume

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

//

void TestControlsController::testHandleEventSetVolume()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventSetVolume()"));

    init();

    int value = 40;

    mController->handleEvent( EControlCmdSetVolume, value );

    QVERIFY( mController->mVolumeControl->mValue == value );

    cleanup();

}

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

// TestControlsController::testHandleEventSetAspectRatio

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

//

void TestControlsController::testHandleEventSetAspectRatio()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventSetAspectRatio()"));

    init();

    int numScalingType = 5;

    for ( int i = 0; i < numScalingType; i++ )

    {

        mController->handleEvent( EControlCmdSetAspectRatio, i );

        QVERIFY( mController->mControls[0]->mAspectRatio == i );

    }

    cleanup();

}

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

// TestControlsController::testHandleEventSetDownloadSize

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

//

void TestControlsController::testHandleEventSetDownloadSize()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventSetDownloadSize()") );

    init();

    int value = 50;

    mController->handleEvent( EControlCmdSetDownloadSize, value );

    QVERIFY( mController->mControls[0]->mDownloadSize == value );

    cleanup();

}

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

// TestControlsController::testHandleEventDownloadUpdated

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

//

void TestControlsController::testHandleEventDownloadUpdated()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventDownloadUpdated()") );

    init();

    int value = 55;

    mController->handleEvent( EControlCmdDownloadUpdated, value );

    QVERIFY( mController->mControls[0]->mDownloadPosition == value );

    cleanup();

}

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

// TestControlsController::testHandleEventDownloadComplete

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

//

void TestControlsController::testHandleEventDownloadComplete()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventDownloadComplete()") );

    init();

    int value = 60;

    mController->handleEvent( EControlCmdDownloadComplete, value );

    QVERIFY( mController->mControls[0]->mDownloadPosition == value );

    cleanup();

}

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

// TestControlsController::testHandleEventSetDownloadPaused

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

//

void TestControlsController::testHandleEventSetDownloadPaused()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventSetDownloadPaused()") );

    init();

    int value = 0;

    mController->handleEvent( EControlCmdSetDownloadPaused, value );

    QVERIFY( mController->mControlsConfig->mState == KControlListsUpdated );

    cleanup();

}

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

// TestControlsController::testHandleEventClearDownloadPaused

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

//

void TestControlsController::testHandleEventClearDownloadPaused()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventClearDownloadPaused()") );

    init();

    int value = 0;

    mController->handleEvent( EControlCmdClearDownloadPaused, value );

    QVERIFY( mController->mControlsConfig->mState == KControlListsUpdated );

    cleanup();

}

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

// TestControlsController::testHandleEventTvOutConnected

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

//

void TestControlsController::testHandleEventTvOutConnected()

{

    MPX_DEBUG(_L("TestControlsController::testHandleEventTvOutConnected()") );

    init();

    //

    // TV-Out Connected, value = true, EMPXVideoLocal

    //

    mController->handleEvent( EControlCmdTvOutConnected, true );

    verifyHandleEventTvOutResult( true, true );

    //

    // TV-Out Connected, value = false, EMPXVideoLocal

    //

    mController->handleEvent( EControlCmdTvOutConnected, false );

    verifyHandleEventTvOutResult( true, false );

    //

    // TV-Out Connected, value = false, non-EMPXVideoLocal