--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoplayback/videoplaybackview/tsrc/testcontrolscontroller/src/testcontrolscontroller.cpp Wed Aug 18 09:50:14 2010 +0300
@@ -0,0 +1,1308 @@
+/**
+* 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: 14 %
+
+#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
+ //
+ mController->mFileDetails->mPlaybackMode = EMPXVideoStreaming;
+ mController->handleEvent( EControlCmdTvOutConnected, false );
+ verifyHandleEventTvOutResult( true, false );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::verifyHandleEventTvOutResult
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::verifyHandleEventTvOutResult( bool tvOutConnected,
+ bool value )
+{
+ MPX_DEBUG(_L("TestControlsController::verifyHandleEventTvOutResult(%d,%d)"),
+ tvOutConnected, value );
+
+ QVERIFY( mController->mFileDetails->mTvOutConnected == tvOutConnected );
+
+ //
+ // validate setDefaultBitmap()
+ //
+ for ( int i=0 ; i < mController->mLoader->mWidgets.count() ; i++ )
+ {
+ bool val = mController->mLoader->isVisible(i);
+
+ if( mController->mLoader->mWidgets[i]->objectName() == QString( "tvOutBitmap" ) )
+ {
+ QVERIFY( tvOutConnected? val == true : val == false );
+ }
+ else if( mController->mLoader->mWidgets[i]->objectName() == QString( "realAudioOnlyBitmap" ) )
+ {
+ QVERIFY( mFileDetails->mRNFormat? val == true : val == false );
+ }
+ else if( mController->mLoader->mWidgets[i]->objectName() == QString( "partialAudioOnlyBitmap" ) )
+ {
+ QVERIFY( mFileDetails->mPartialPlayback? val == true : val == false );
+ }
+ else if( mController->mLoader->mWidgets[i]->objectName() == QString( "audioOnlyBitmap" ) )
+ {
+ QVERIFY( tvOutConnected? val == false : val == true );
+ }
+ }
+
+ //
+ // validate generateThumbNail()
+ //
+ if ( tvOutConnected )
+ {
+ QVERIFY( ( mController->mFileDetails->mPlaybackMode == EMPXVideoLocal )?
+ mController->mThumbNailState == EThumbNailRequsted :
+ mController->mThumbNailState == EThumbNailNotAvailable );
+ QVERIFY( mController->mViewMode == EAudioOnlyView );
+ QVERIFY( mController->mControlsConfig->mState == EControlCmdTvOutConnected );
+ QVERIFY( mController->mThumbnailManager->mThumbSize == ThumbnailManager::ThumbnailLarge );
+ QVERIFY( mController->mThumbnailManager->mQuality == ThumbnailManager::OptimizeForPerformance );
+ QVERIFY( mController->mViewTransitionIsGoingOn == false );
+ }
+ else if ( mController->mFileDetails->mVideoEnabled )
+ {
+ QVERIFY( mController->mViewTransitionIsGoingOn == true );
+ QVERIFY( mController->mViewMode == EFullScreenView );
+ }
+ else if ( ! mController->mFileDetails->mVideoEnabled )
+ {
+ QVERIFY( mController->mViewTransitionIsGoingOn == false );
+ QVERIFY( mController->mViewMode == EAudioOnlyView );
+ }
+
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testHandleEventTvOutDisconnected
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testHandleEventTvOutDisconnected()
+{
+ MPX_DEBUG(_L("TestControlsController::testHandleEventTvOutDisconnected()") );
+
+ init();
+
+ //
+ // TV-Out Disconnected, value = true
+ //
+ mController->handleEvent( EControlCmdTvOutDisconnected, true );
+ verifyHandleEventTvOutResult( false, true );
+
+ //
+ // TV-Out Disconnected, value = false
+ //
+ mController->handleEvent( EControlCmdTvOutDisconnected, false );
+ verifyHandleEventTvOutResult( false, false );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testHandleEventHandleErrors
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testHandleEventHandleErrors()
+{
+ MPX_DEBUG(_L("TestControlsController::testHandleEventHandleErrors()") );
+
+ init();
+
+ //
+ // handle error
+ //
+ mController->handleEvent( EControlCmdHandleErrors, 0 );
+
+ QVERIFY( mController->mThumbNailState == EThumbNailEmpty );
+ QVERIFY( mController->mState == EPbStateNotInitialised );
+ QVERIFY( mController->mViewMode == EFullScreenView );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testHandleEventShowVolumeControls
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testHandleEventShowVolumeControls()
+{
+ MPX_DEBUG(_L("TestControlsController::testHandleEventShowVolumeControls()") );
+
+ init();
+
+ mController->handleEvent( EControlCmdShowVolumeControls, 0 );
+
+ QVERIFY( mController->mVolumeControl->mVisible == true );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testHandleCommand
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testHandleCommand()
+{
+ MPX_DEBUG(_L("TestControlsController::testHandleCommand()") );
+
+ init();
+
+ mController->handleCommand( EMPXPbvCmdSetPosition, 0 );
+ QVERIFY( mViewWrapper->mProperty == EPbPropertyPosition );
+
+ mController->handleCommand( EMPXPbvCmdSetVolume, 0 );
+ QVERIFY( mViewWrapper->mProperty == EPbPropertyVolume );
+
+ mController->handleCommand( EMPXPbvCmdPlay, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPlay );
+
+ mController->handleCommand( EMPXPbvCmdPause, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPause );
+
+ mController->handleCommand( EMPXPbvCmdPlayPause, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPlayPause );
+
+ mController->handleCommand( EMPXPbvCmdStop, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdStop );
+
+ mController->handleCommand( EMPXPbvCmdClose, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdClose );
+
+ mController->handleCommand( EMPXPbvCmdMute, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdMute );
+
+ mController->handleCommand( EMPXPbvCmdUnMute, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdUnMute );
+
+ mController->handleCommand( EMPXPbvCmdChangeAspectRatio, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdChangeAspectRatio );
+
+ mController->handleCommand( EMPXPbvCmdNaturalAspectRatio, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdNaturalAspectRatio );
+
+ mController->handleCommand( EMPXPbvCmdZoomAspectRatio, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdZoomAspectRatio );
+
+ mController->handleCommand( EMPXPbvCmdStretchAspectRatio, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdStretchAspectRatio );
+
+ mController->handleCommand( EMPXPbvCmdSeekForward, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdSeekForward );
+
+ mController->handleCommand( EMPXPbvCmdSeekBackward, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdSeekBackward );
+
+ mController->handleCommand( EMPXPbvCmdEndSeek, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdEndSeek );
+
+ mController->handleCommand( EMPXPbvCmdNextListItem, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdNextListItem );
+
+ mController->handleCommand( EMPXPbvCmdPreviousListItem, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPreviousListItem );
+
+ mController->handleCommand( EMPXPbvCmdDecreaseVolume, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdDecreaseVolume );
+
+ mController->handleCommand( EMPXPbvCmdIncreaseVolume, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdIncreaseVolume );
+
+ mController->handleCommand( EMPXPbvCmdPosition, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPosition );
+
+ mController->handleCommand( EMPXPbvCmdSave, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdSave );
+
+ mController->handleCommand( EMPXPbvCmdResetControls, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdResetControls );
+
+ mController->handleCommand( EMPXPbvCmdShortPressForward, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdShortPressForward );
+
+ mController->handleCommand( EMPXPbvCmdShortPressBackward, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdShortPressBackward );
+
+ mController->handleCommand( EMPXPbvCmdShowFileDetails, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdShowFileDetails );
+
+ mController->handleCommand( EMPXPbvCmdEndOfClip, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdEndOfClip );
+
+ mController->handleCommand( EMPXPbvCmdCustomPause, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdCustomPause );
+
+ mController->handleCommand( EMPXPbvCmdCustomPlay, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdCustomPlay );
+
+ mController->handleCommand( EMPXPbvCmdExit, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdExit );
+
+ mController->handleCommand( EMPXPbvLaunchDRMDetails, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvLaunchDRMDetails );
+
+ mController->handleCommand( EMPXPbvSurfaceCreated, 0 );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvSurfaceCreated );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testHandleTappedOnScreen
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testHandleTappedOnScreen()
+{
+ MPX_DEBUG(_L("TestControlsController::testHandleTappedOnScreen()") );
+
+ init();
+ mController->mOrientation = Qt::Horizontal;
+ connect( this, SIGNAL( commandSignal() ), mController, SLOT( handleTappedOnScreen() ) );
+
+ //
+ // 1. Test full screen view
+ //
+ mController->mViewMode = EFullScreenView;
+
+ //
+ // (1a) playing state
+ //
+ mController->mState = EPbStatePlaying;
+ emit commandSignal();
+
+ QVERIFY( mController->mControlsTimer->isActive() == true );
+ for ( int i = 0 ; i < mController->mControls.count() ; i++ )
+ {
+ QVERIFY( mController->mControls[i]->mVisibilityState == mController->mState );
+ }
+
+ //
+ // (1b) pause state
+ //
+ mController->mState = EPbStatePaused;
+ emit commandSignal();
+
+ QVERIFY( mController->mControlsTimer->isActive() == false );
+ for ( int i = 0 ; i < mController->mControls.count() ; i++ )
+ {
+ QVERIFY( mController->mControls[i]->mVisibilityState == mController->mState );
+ }
+
+
+ //
+ // 2. Test details screen view
+ //
+ mController->mViewMode = EDetailsView;
+
+ //
+ // (2a) non-pausable stream, currently in 'playing' state
+ //
+ mController->mFileDetails->mPausableStream = false;
+ mController->mViewWrapper->HandleCommandL( EMPXPbvCmdSetVolume ); // set a random cmd
+ mController->mState = EPbStatePlaying;
+
+ emit commandSignal();
+ QVERIFY( mController->mViewWrapper->mCommandId == EMPXPbvCmdSetVolume );
+
+ //
+ // (2b) pausable stream, currently in 'playing' state
+ //
+ mController->mFileDetails->mPausableStream = true;
+ mController->mViewWrapper->HandleCommandL( EMPXPbvCmdChangeAspectRatio ); // set a random cmd
+ mController->mState = EPbStatePlaying;
+
+ emit commandSignal();
+ QVERIFY( mController->mViewWrapper->mCommandId == EMPXPbvCmdPlayPause );
+
+ //
+ // (2c) non-pausable stream, currently in 'paused' state
+ //
+ mController->mFileDetails->mPausableStream = false;
+ mController->mViewWrapper->HandleCommandL( EMPXPbvCmdEndSeek ); // set a random cmd
+ mController->mState = EPbStatePaused;
+
+ emit commandSignal();
+ QVERIFY( mController->mViewWrapper->mCommandId == EMPXPbvCmdPlayPause );
+
+ //
+ // (2d) pausable stream, currently in 'paused' state
+ //
+ mController->mFileDetails->mPausableStream = true;
+ mController->mViewWrapper->HandleCommandL( EMPXPbvCmdSave ); // set a random cmd
+ mController->mState = EPbStatePaused;
+
+ emit commandSignal();
+ QVERIFY( mController->mViewWrapper->mCommandId == EMPXPbvCmdPlayPause );
+
+ //
+ // disconnect signal and clean up
+ //
+ disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( handleTappedOnScreen() ) );
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testUpdateVideoRectDone
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testUpdateVideoRectDone()
+{
+ MPX_DEBUG(_L("TestControlsController::testUpdateVideoRectDone()") );
+
+ init();
+
+ mController->updateVideoRectDone();
+
+ //
+ // default is full-screen
+ //
+ QVERIFY( mController->mControlsConfig->mState == EControlCmdFullScreenViewOpened );
+
+ //
+ // validate Details view
+ //
+ mController->mViewMode = EDetailsView;
+
+ mController->updateVideoRectDone();
+
+ QVERIFY( mController->mControlsConfig->mState == EControlCmdDetailsViewOpened );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testIsAttachOperation
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testIsAttachOperation()
+{
+ MPX_DEBUG(_L("TestControlsController::testIsAttachOperation()") );
+
+ //
+ // get access to XQServiceUtilXtra stub
+ //
+ XQServiceUtilXtra* extraUtil = XQServiceUtilXtra::instance();
+
+ //
+ // set service enable
+ //
+ extraUtil->setCurrentService( true );
+
+ //
+ // initialize controlscontroller
+ //
+ init();
+
+ //
+ // verify 'mIsAttachOperation' flag is enabled
+ //
+ QVERIFY( mController->mIsAttachOperation == true );
+
+ //
+ // clean up
+ //
+ cleanup();
+
+ //
+ // set service disable
+ //
+ extraUtil->setCurrentService( false );
+
+ //
+ // initialize controlscontroller
+ //
+ init();
+
+ //
+ // verify 'mIsAttachOperation' flag is disabled
+ //
+ QVERIFY( mController->mIsAttachOperation == false );
+
+ //
+ // clean up
+ //
+ cleanup();
+
+ //
+ // dereference extraUtil count
+ //
+ extraUtil->decreaseReferenceCount();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testslot_skipToNextVideoItem
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testslot_skipToNextVideoItem()
+{
+ MPX_DEBUG(_L("TestControlsController::testslot_skipToNextVideoItem()") );
+
+ init();
+
+ connect( this, SIGNAL( commandSignal() ), mController, SLOT( skipToNextVideoItem() ) );
+
+ //
+ // If we are not in full screen view, ignore
+ //
+ mViewWrapper->mCommandId = EMPXPbvCmdPosition;
+ mController->mViewMode = EDetailsView;
+
+ emit commandSignal();
+
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPosition );
+
+ //
+ // If we are in full screen view, issue EMPXPbvCmdNextListItem;
+ //
+ mController->mViewMode = EFullScreenView;
+
+ emit commandSignal();
+
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdNextListItem );
+
+ disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( skipToNextVideoItem() ) );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testslot_skipToPreviousVideoItem
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testslot_skipToPreviousVideoItem()
+{
+ MPX_DEBUG(_L("TestControlsController::testslot_skipToPreviousVideoItem()") );
+
+ init();
+
+ connect( this, SIGNAL( commandSignal() ), mController, SLOT( skipToPreviousVideoItem() ) );
+
+ //
+ // If we are not in full screen view, ignore
+ //
+ mViewWrapper->mCommandId = EMPXPbvCmdPosition;
+ mController->mViewMode = EDetailsView;
+
+ emit commandSignal();
+
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPosition );
+
+ //
+ // If we are in full screen view, issue EMPXPbvCmdPreviousListItem
+ //
+ mController->mViewMode = EFullScreenView;
+
+ emit commandSignal();
+
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPreviousListItem );
+
+ disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( skipToPreviousVideoItem() ) );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testslot_attachVideo
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testslot_attachVideo()
+{
+ MPX_DEBUG(_L("TestControlsController::testslot_attachVideo()") );
+
+ //
+ // get access to XQServiceUtilXtra stub to enable XQServiceUtil::isService() method
+ //
+ XQServiceUtilXtra* extraUtil = XQServiceUtilXtra::instance();
+
+ //
+ // set service enable
+ //
+ extraUtil->setCurrentService( true );
+
+ //
+ // initialize controlscontroller
+ //
+ init();
+
+ //
+ // verify view closePlaybackView() slot is not yet called
+ //
+ QVERIFY( mController->mView->mViewClosed == false );
+
+ //
+ // connect signal with controller attachVideo() slot
+ //
+ bool res = connect( this, SIGNAL( commandSignal() ), mController, SLOT( attachVideo() ) );
+
+ //
+ // emit signal, this will in turns invoke videoservices itemSelected() slot
+ //
+ emit commandSignal();
+
+ //
+ // verify view closePlaybackView() slot is called
+ //
+ QVERIFY( mController->mView->mViewClosed == true );
+
+ //
+ // verify videoservices itemSelected() slot is called
+ //
+ QVERIFY( mController->mVideoServices->mItemSelected == true );
+
+ //
+ // disconnect signal
+ //
+ disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( attachVideo() ) );
+
+ //
+ // clean up
+ //
+ cleanup();
+
+ //
+ // dereference extraUtil count
+ //
+ extraUtil->decreaseReferenceCount();
+
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testslot_sendVideo
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testslot_sendVideo()
+{
+ MPX_DEBUG(_L("TestControlsController::testslot_sendVideo()") );
+
+ //
+ // initialize controlscontroller
+ //
+ init();
+
+ //
+ // connect signal with controller sendVideoo() slot
+ //
+ bool res = connect( this, SIGNAL( commandSignal() ), mController, SLOT( sendVideo() ) );
+
+ //
+ // emit signal, this will in turns invoke mController sendVideo() slot
+ //
+ emit commandSignal();
+
+ //
+ // disconnect signal
+ //
+ disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( sendVideo() ) );
+
+ //
+ // clean up
+ //
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testslot_handleOrientationChanged
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testslot_handleOrientationChanged()
+{
+ MPX_DEBUG(_L("TestControlsController::testslot_handleOrientationChanged()") );
+
+ //
+ // initialize controlscontroller
+ //
+ init();
+
+ //
+ // connect signal with controller handleOrientationChanged() slot
+ //
+ bool res = connect( this, SIGNAL( commandSignal( Qt::Orientation ) ),
+ mController, SLOT( handleOrientationChanged( Qt::Orientation ) ) );
+
+ //
+ // emit signal, this will in turns invoke mController handleOrientationChanged() slot
+ //
+ mController->mOrientation = Qt::Vertical;
+ mController->mState = EPbStatePlaying;
+
+ emit commandSignal( Qt::Horizontal );
+
+ QVERIFY( mController->mOrientation == Qt::Horizontal );
+
+ for ( int i = 0 ; i < mController->mControls.count() ; i++ )
+ {
+ QVERIFY( mController->mControls[i]->mVisibilityState == mController->mState );
+ }
+
+ //
+ // disconnect signal
+ //
+ disconnect( this, SIGNAL( commandSignal( Qt::Orientation ) ),
+ mController, SLOT( handleOrientationChanged( Qt::Orientation ) ) );
+
+ //
+ // clean up
+ //
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testslot_handleRNLogoVisibleChanged
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testslot_handleRNLogoVisibleChanged()
+{
+ MPX_DEBUG(_L("TestControlsController::testslot_handleRNLogoVisibleChanged()") );
+
+ //
+ // initialize controlscontroller
+ //
+ init();
+
+ //
+ // connect signal with controller handleRNLogoVisibleChanged() slot
+ //
+ bool res = connect( this, SIGNAL( commandSignal() ),
+ mController, SLOT( handleRNLogoVisibleChanged() ) );
+
+ //
+ // emit signal, this will in turns invoke mController handleRNLogoVisibleChanged() slot
+ //
+ emit commandSignal();
+
+ QVERIFY( mController->mRNLogoTimer->isActive() );
+ QVERIFY( mController->mRNLogoTimer->interval() == KRNLogoTimeOut );
+
+ //
+ // disconnect signal
+ //
+ disconnect( this, SIGNAL( commandSignal() ),
+ mController, SLOT( handleRNLogoVisibleChanged() ) );
+
+ //
+ // clean up
+ //
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testslot_handleRNLogoTimeout
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testslot_handleRNLogoTimeout()
+{
+ MPX_DEBUG(_L("TestControlsController::testslot_handleRNLogoTimeout()") );
+
+ //
+ // initialize controlscontroller
+ //
+ init();
+
+ if ( ! mController->mRNLogoTimer )
+ {
+ mController->mRNLogoTimer = new QTimer( mController );
+ }
+
+ //
+ // connect signal with controller handleRNLogoTimeout() slot
+ //
+ bool res = connect( this, SIGNAL( commandSignal() ),
+ mController, SLOT( handleRNLogoTimeout() ) );
+
+ //
+ // emit signal, this will in turns invoke mController handleRNLogoTimeout() slot
+ //
+ emit commandSignal();
+
+ QVERIFY( ! mController->mRNLogoTimer->isActive() );
+ QVERIFY( mController->mControlsConfig->mState == KControlListsUpdated );
+ QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdRealOneBitmapTimeout );
+
+ //
+ // disconnect signal
+ //
+ disconnect( this, SIGNAL( commandSignal() ),
+ mController, SLOT( handleRNLogoTimeout() ) );
+
+ //
+ // clean up
+ //
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testIsRNLogoBitmapVisible
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testIsRNLogoBitmapVisible()
+{
+ MPX_DEBUG(_L("TestControlsController::testIsRNLogoBitmapVisible()"));
+
+ init();
+
+ QVERIFY( mController->isRNLogoBitmapInControlList() );
+
+ //
+ // Remove RN logo from the list
+ //
+ for ( int i = 0 ; i < mController->mControls.count() ; i++ )
+ {
+ if( mController->mControls[i]->mControlIndex == ERealLogoBitmap )
+ {
+ mController->mControls.removeAt( i );
+ }
+ }
+
+ QVERIFY( ! mController->isRNLogoBitmapInControlList() );
+
+ cleanup();
+}
+
+// -------------------------------------------------------------------------------------------------
+// TestControlsController::testIsFileDetailsAdded
+// -------------------------------------------------------------------------------------------------
+//
+void TestControlsController::testIsFileDetailsAdded()
+{
+ MPX_DEBUG(_L("TestControlsController::testIsFileDetailsAdded()"));
+
+ init();
+
+ QVERIFY( ! mController->isFileDetailsAdded() );
+
+ mFileDetails = new VideoPlaybackViewFileDetails();
+ mFileDetails->mClipName = QString( "testClip.rm" );
+ mFileDetails->mMimeType = QString( "video/x-pn-realvideo" );
+
+ mController->addFileDetails( mFileDetails );
+
+ QVERIFY( mController->isFileDetailsAdded() );
+
+ cleanup();
+}
+
+// End of file