/**

* 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

*/

#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 "mpxvideoplaybackcontrol.hrh"

#include "mpxcommonvideoplaybackview.hrh"

#include "testmpxvideoplaybackcontrolscontroller.h"

#include "hbvideobaseplaybackview.h"

#include "mpxvideoplaybackviewfiledetails.h"

#include "mpxvideoviewwrapper.h"

#include "mpxvideoplaybackfullscreencontrol.h"

#include "mpxvideoplaybackcontrolconfiguration.h"

#include "thumbnailmanager_qt.h"

#include "mpxvideoplaybackdocumentloader.h"

#include "hbvolumesliderpopup.h"

#include "videoservices.h"

#include "xqserviceutilxtra.h"

#define private public

#include "mpxvideoplaybackcontrolscontroller.h"

#undef private

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

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

// main

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

//

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

{

    HbApplication app(argc, argv);

    HbMainWindow window;

    TestMPXVideoPlaybackControlsController tv;

    char *pass[3];

    pass[0] = argv[0];

    pass[1] = "-o";

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

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

    return res;

}

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

// init

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

//

void TestMPXVideoPlaybackControlsController::init()

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

    mBaseVideoView = new HbVideoBasePlaybackView();

    if ( ! mFileDetails )

    {

    }

    mController    = new QMPXVideoPlaybackControlsController( mBaseVideoView,

                                                              mViewWrapper,

}

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

// cleanup

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

//

void TestMPXVideoPlaybackControlsController::cleanup()

{

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

    delete mController;

    mController = NULL;

    delete mFileDetails;

    mFileDetails = NULL;

    delete mViewWrapper;

    mViewWrapper = NULL;

    delete mBaseVideoView;

    mBaseVideoView = NULL;

}

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

// TestMPXVideoPlaybackControlsController::testAddFileDetails

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

//

void TestMPXVideoPlaybackControlsController::testAddFileDetails()

{

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

    //

    // local real media with no video

    //

    mFileDetails = new QMPXVideoPlaybackViewFileDetails();

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

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

    init();

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

    QVERIFY( mController->mViewMode == EAudioOnlyView );

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

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

    //

    // local 3GPP media with video-only

    //

    mFileDetails = new QMPXVideoPlaybackViewFileDetails();

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

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

    mFileDetails->mVideoEnabled = true;

    mFileDetails->mTvOutConnected = true;

    init();

    mController->mViewMode = EFullScreenView;

    QFileInfo videoOnlyFile( mFileDetails->mClipName );

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

    //

    // validate 'TvOutConnected'

    //

    verifyHandleEventTvOutResult(true, true);

    //

    // video-only, validate volume control is dimmed

    //

    //

    // 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" ) )

            break;

        }

    //

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

    //

    mFileDetails = new QMPXVideoPlaybackViewFileDetails();

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

    mFileDetails->mPlaybackMode = EMPXVideoStreaming;

    mFileDetails->mTvOutConnected = false;

    mFileDetails->mAudioEnabled = true;

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

    init();

    QVERIFY( mController->mFileDetails->mRNFormat == 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" ) )

            break;

        }

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventSetPosition

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventSetPosition()

{

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

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventSetDuration

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventSetDuration()

{

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

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventStateChanged

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventStateChanged()

{

    TMPXVideoPlaybackControlCommandIds event = EMPXControlCmdStateChanged;

    mController->mOrientation = Qt::Horizontal;

    //

    // state change (EPbStateInitialising)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateBuffering)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStatePlaying)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStatePaused)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateNotInitialised)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateStopped)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateSeekingForward)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateSeekingBackward)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateShuttingDown)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStateDownloading)

    //

    verifyHandleEventStateChangedResult( value );

    //

    // state change (EPbStatePluginSeeking)

    //

    verifyHandleEventStateChangedResult( value );

}

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

// TestMPXVideoPlaybackControlsController::verifyHandleEventStateChangedResult

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

//

void TestMPXVideoPlaybackControlsController::verifyHandleEventStateChangedResult( int value )

{

    mController->mOrientation = Qt::Horizontal;

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

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

    {

    }

              value == EPbStateNotInitialised )

    {

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

        {

        }

    }

    else

    {

    }

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventSetVolume

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventSetVolume()

{

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventSetAspectRatio

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventSetAspectRatio()

{

    int numScalingType = 5;

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

    }

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventSetDownloadSize

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventSetDownloadSize()

{

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

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventDownloadUpdated

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventDownloadUpdated()

{

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

    int value = 55;

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventDownloadComplete

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventDownloadComplete()

{

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

    int value = 60;

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventSetDownloadPaused

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventSetDownloadPaused()

{

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

    int value = 0;

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventClearDownloadPaused

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

//

void TestMPXVideoPlaybackControlsController::testHandleEventClearDownloadPaused()

{

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

    int value = 0;

}

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

// TestMPXVideoPlaybackControlsController::testHandleEventTvOutConnected