1 /**

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   tester for methods in Video Playback Controls Controller

    15 *

    16 */

    17 

    18 // Version : %version:  13 %

    19 

    20 #include <e32err.h>

    21 #include <w32std.h>

    22 #include <qobject>

    23 

    24 #include <hbapplication.h>

    25 #include <hbinstance.h>

    26 #include <hblabel.h>

    27 #include <MMFScalingCustomCommandConstants.h>

    28 

    29 #include "mpxvideo_debug.h"

    30 #include "videoplaybackcontrol.hrh"

    31 #include "mpxcommonvideoplaybackview.hrh"

    32 #include "testcontrolscontroller.h"

    33 #include "videobaseplaybackview.h"

    34 #include "videoplaybackviewfiledetails.h"

    35 #include "mpxvideoviewwrapper.h"

    36 #include "videoplaybackfullscreencontrol.h"

    37 #include "videoplaybackcontrolconfiguration.h"

    38 #include "thumbnailmanager_qt.h"

    39 #include "videoplaybackdocumentloader.h"

    40 #include "hbvolumesliderpopup.h"

    41 #include "videoservices.h"

    42 #include "xqserviceutilxtra.h"

    43 

    44 #define private public

    45 #include "videoplaybackcontrolscontroller.h"

    46 #undef private

    47 

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

    49 

    50 // ---------------------------------------------------------------------------

    51 // main

    52 // ---------------------------------------------------------------------------

    53 //

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

    55 {

    56     HbApplication app(argc, argv);

    57     HbMainWindow window;

    58     TestControlsController tv;

    59 

    60     char *pass[3];

    61     pass[0] = argv[0];

    62     pass[1] = "-o";

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

    64 

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

    66 

    67     return res;

    68 }

    69 

    70 // ---------------------------------------------------------------------------

    71 // init

    72 // ---------------------------------------------------------------------------

    73 //

    74 void TestControlsController::init()

    75 {

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

    77 

    78     mBaseVideoView = new VideoBasePlaybackView();

    79 

    80     if ( ! mFileDetails )

    81     {

    82         mFileDetails   = new VideoPlaybackViewFileDetails();

    83     }

    84 

    85     mViewWrapper   = CMPXVideoViewWrapper::NewL( mBaseVideoView );

    86     mController    = new VideoPlaybackControlsController( mBaseVideoView,

    87                                                           mViewWrapper,

    88                                                           mFileDetails );

    89 }

    90 

    91 // ---------------------------------------------------------------------------

    92 // cleanup

    93 // ---------------------------------------------------------------------------

    94 //

    95 void TestControlsController::cleanup()

    96 {

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

    98 

    99     delete mController;

   100     mController = NULL;

   101 

   102     delete mFileDetails;

   103     mFileDetails = NULL;

   104 

   105     delete mViewWrapper;

   106     mViewWrapper = NULL;

   107 

   108     delete mBaseVideoView;

   109     mBaseVideoView = NULL;

   110 }

   111 

   112 // -------------------------------------------------------------------------------------------------

   113 // TestControlsController::testAddFileDetails

   114 // -------------------------------------------------------------------------------------------------

   115 //

   116 void TestControlsController::testAddFileDetails()

   117 {

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

   119 

   120     //

   121     // local real media with no video

   122     //

   123     mFileDetails = new VideoPlaybackViewFileDetails();

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

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

   126 

   127     init();

   128 

   129     mController->addFileDetails( mFileDetails );

   130 

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

   132     QVERIFY( mController->mViewMode == EAudioOnlyView );

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

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

   135 

   136     cleanup();

   137 

   138     //

   139     // local 3GPP media with video-only

   140     //

   141     mFileDetails = new VideoPlaybackViewFileDetails();

   142 

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

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

   145     mFileDetails->mVideoEnabled = true;

   146     mFileDetails->mTvOutConnected = true;

   147 

   148     init();

   149 

   150     mController->mViewMode = EFullScreenView;

   151     QFileInfo videoOnlyFile( mFileDetails->mClipName );

   152 

   153     mController->addFileDetails( mFileDetails );

   154 

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

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

   157 

   158     //

   159     // validate 'TvOutConnected'

   160     //

   161     verifyHandleEventTvOutResult(true, true);

   162 

   163     //

   164     // video-only, validate volume control is dimmed

   165     //

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

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

   168 

   169     //

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

   171     //

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

   173     {

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

   175         {

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

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

   178             break;

   179         }

   180     }

   181     cleanup();

   182 

   183     //

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

   185     //

   186     mFileDetails = new VideoPlaybackViewFileDetails();

   187 

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

   189     mFileDetails->mPlaybackMode = EMPXVideoStreaming;

   190     mFileDetails->mTvOutConnected = false;

   191     mFileDetails->mAudioEnabled = true;

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

   193 

   194     init();

   195 

   196     mController->addFileDetails( mFileDetails );

   197 

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

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

   200 

   201     //

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

   203     //

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

   205     {

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

   207         {

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

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

   210             break;

   211         }

   212     }

   213 

   214     cleanup();

   215 }

   216 

   217 // -------------------------------------------------------------------------------------------------

   218 // TestControlsController::testHandleEventSetPosition

   219 // -------------------------------------------------------------------------------------------------

   220 //

   221 void TestControlsController::testHandleEventSetPosition()

   222 {

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

   224 

   225     init();

   226     int value = 20000;

   227 

   228     mController->handleEvent( EControlCmdSetPosition, value );

   229 

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

   231 

   232     cleanup();

   233 }

   234 

   235 // -------------------------------------------------------------------------------------------------

   236 // TestControlsController::testHandleEventSetDuration

   237 // -------------------------------------------------------------------------------------------------

   238 //

   239 void TestControlsController::testHandleEventSetDuration()

   240 {

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

   242 

   243     init();

   244     int value = 30000;

   245 

   246     mController->handleEvent( EControlCmdSetDuration, value );

   247 

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

   249 

   250     cleanup();

   251 }

   252 

   253 // -------------------------------------------------------------------------------------------------

   254 // TestControlsController::testHandleEventStateChanged

   255 // -------------------------------------------------------------------------------------------------

   256 //

   257 void TestControlsController::testHandleEventStateChanged()

   258 {

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

   260 

   261     init();

   262     TVideoPlaybackControlCommandIds event = EControlCmdStateChanged;

   263     mController->mOrientation = Qt::Horizontal;

   264 

   265     //

   266     // state change (EPbStateInitialising)

   267     //

   268     int value = EPbStateInitialising;

   269     mController->handleEvent( event, value );

   270     verifyHandleEventStateChangedResult( value );

   271 

   272     //

   273     // state change (EPbStateBuffering)

   274     //

   275     value = EPbStateBuffering;

   276     mController->handleEvent( event, value );

   277     verifyHandleEventStateChangedResult( value );

   278 

   279     //

   280     // state change (EPbStatePlaying)

   281     //

   282     value = EPbStatePlaying;

   283     mController->handleEvent( event, value );

   284     verifyHandleEventStateChangedResult( value );

   285 

   286     //

   287     // state change (EPbStatePaused)

   288     //

   289     value = EPbStatePaused;

   290     mController->handleEvent( event, value );

   291     verifyHandleEventStateChangedResult( value );

   292 

   293     //

   294     // state change (EPbStateNotInitialised)

   295     //

   296     value = EPbStateNotInitialised;

   297     mController->handleEvent( event, value );

   298     verifyHandleEventStateChangedResult( value );

   299 

   300     //

   301     // state change (EPbStateStopped)

   302     //

   303     value = EPbStateStopped;

   304     mController->handleEvent( event, value );

   305     verifyHandleEventStateChangedResult( value );

   306 

   307     //

   308     // state change (EPbStateSeekingForward)

   309     //

   310     value = EPbStateSeekingForward;

   311     mController->handleEvent( event, value );

   312     verifyHandleEventStateChangedResult( value );

   313 

   314     //

   315     // state change (EPbStateSeekingBackward)

   316     //

   317     value = EPbStateSeekingBackward;

   318     mController->handleEvent( event, value );

   319     verifyHandleEventStateChangedResult( value );

   320 

   321     //

   322     // state change (EPbStateShuttingDown)

   323     //

   324     value = EPbStateShuttingDown;

   325     mController->handleEvent( event, value );

   326     verifyHandleEventStateChangedResult( value );

   327 

   328     //

   329     // state change (EPbStateDownloading)

   330     //

   331     value = EPbStateDownloading;

   332     mController->handleEvent( event, value );

   333     verifyHandleEventStateChangedResult( value );

   334 

   335     //

   336     // state change (EPbStatePluginSeeking)

   337     //

   338     value = EPbStatePluginSeeking;

   339     mController->handleEvent( event, value );

   340     verifyHandleEventStateChangedResult( value );

   341 

   342     cleanup();

   343 }

   344 

   345 // -------------------------------------------------------------------------------------------------

   346 // TestControlsController::verifyHandleEventStateChangedResult

   347 // -------------------------------------------------------------------------------------------------

   348 //

   349 void TestControlsController::verifyHandleEventStateChangedResult( int value )

   350 {

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

   352 

   353     mController->mOrientation = Qt::Horizontal;

   354 

   355     if ( value == EPbStateInitialised &&

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

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

   358     {

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

   360     }

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

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

   363               value == EPbStateNotInitialised )

   364     {

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

   366         {

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

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

   369         }

   370     }

   371     else

   372     {

   373         QVERIFY( mController->mState == value );

   374     }

   375 }

   376 

   377 // -------------------------------------------------------------------------------------------------

   378 // TestControlsController::testHandleEventSetVolume

   379 // -------------------------------------------------------------------------------------------------

   380 //

   381 void TestControlsController::testHandleEventSetVolume()

   382 {

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

   384 

   385     init();

   386     int value = 40;

   387 

   388     mController->handleEvent( EControlCmdSetVolume, value );

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

   390 

   391     cleanup();

   392 }

   393 

   394 // -------------------------------------------------------------------------------------------------

   395 // TestControlsController::testHandleEventSetAspectRatio

   396 // -------------------------------------------------------------------------------------------------

   397 //

   398 void TestControlsController::testHandleEventSetAspectRatio()

   399 {

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

   401 

   402     init();

   403     int numScalingType = 5;

   404 

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

   406     {

   407         mController->handleEvent( EControlCmdSetAspectRatio, i );

   408 

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

   410     }

   411 

   412     cleanup();

   413 }

   414 

   415 // -------------------------------------------------------------------------------------------------

   416 // TestControlsController::testHandleEventSetDownloadSize

   417 // -------------------------------------------------------------------------------------------------

   418 //

   419 void TestControlsController::testHandleEventSetDownloadSize()

   420 {

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

   422 

   423     init();

   424     int value = 50;

   425 

   426     mController->handleEvent( EControlCmdSetDownloadSize, value );

   427 

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

   429 

   430     cleanup();

   431 }

   432 

   433 // -------------------------------------------------------------------------------------------------

   434 // TestControlsController::testHandleEventDownloadUpdated

   435 // -------------------------------------------------------------------------------------------------

   436 //

   437 void TestControlsController::testHandleEventDownloadUpdated()

   438 {

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

   440 

   441     init();

   442     int value = 55;

   443 

   444     mController->handleEvent( EControlCmdDownloadUpdated, value );

   445 

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

   447 

   448     cleanup();

   449 }

   450 

   451 // -------------------------------------------------------------------------------------------------

   452 // TestControlsController::testHandleEventDownloadComplete

   453 // -------------------------------------------------------------------------------------------------

   454 //

   455 void TestControlsController::testHandleEventDownloadComplete()

   456 {

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

   458 

   459     init();

   460     int value = 60;

   461 

   462     mController->handleEvent( EControlCmdDownloadComplete, value );

   463 

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

   465 

   466     cleanup();

   467 }

   468 

   469 // -------------------------------------------------------------------------------------------------

   470 // TestControlsController::testHandleEventSetDownloadPaused

   471 // -------------------------------------------------------------------------------------------------

   472 //

   473 void TestControlsController::testHandleEventSetDownloadPaused()

   474 {

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

   476 

   477     init();

   478     int value = 0;

   479 

   480     mController->handleEvent( EControlCmdSetDownloadPaused, value );

   481 

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

   483 

   484     cleanup();

   485 }

   486 

   487 // -------------------------------------------------------------------------------------------------

   488 // TestControlsController::testHandleEventClearDownloadPaused

   489 // -------------------------------------------------------------------------------------------------

   490 //

   491 void TestControlsController::testHandleEventClearDownloadPaused()

   492 {

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

   494 

   495     init();

   496     int value = 0;

   497 

   498     mController->handleEvent( EControlCmdClearDownloadPaused, value );

   499 

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

   501 

   502     cleanup();

   503 }

   504 

   505 // -------------------------------------------------------------------------------------------------

   506 // TestControlsController::testHandleEventTvOutConnected

   507 // -------------------------------------------------------------------------------------------------

   508 //

   509 void TestControlsController::testHandleEventTvOutConnected()

   510 {

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

   512 

   513     init();

   514 

   515     //

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

   517     //

   518     mController->handleEvent( EControlCmdTvOutConnected, true );

   519     verifyHandleEventTvOutResult( true, true );

   520 

   521     //

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

   523     //

   524     mController->handleEvent( EControlCmdTvOutConnected, false );

   525     verifyHandleEventTvOutResult( true, false );

   526 

   527     //

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

   529     //

   530     mController->mFileDetails->mPlaybackMode = EMPXVideoStreaming;

   531     mController->handleEvent( EControlCmdTvOutConnected, false );

   532     verifyHandleEventTvOutResult( true, false );

   533 

   534     cleanup();

   535 }

   536 

   537 // -------------------------------------------------------------------------------------------------

   538 // TestControlsController::verifyHandleEventTvOutResult

   539 // -------------------------------------------------------------------------------------------------

   540 //

   541 void TestControlsController::verifyHandleEventTvOutResult( bool tvOutConnected,

   542         bool value )

   543 {

   544     MPX_DEBUG(_L("TestControlsController::verifyHandleEventTvOutResult(%d,%d)"),

   545             tvOutConnected, value );

   546 

   547     QVERIFY( mController->mFileDetails->mTvOutConnected == tvOutConnected );

   548 

   549     //

   550     // validate setDefaultBitmap()

   551     //

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

   553     {

   554         bool val = mController->mLoader->isVisible(i);

   555 

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

   557         {

   558             QVERIFY( tvOutConnected? val == true : val == false );

   559         }

   560         else if( mController->mLoader->mWidgets[i]->objectName() ==  QString( "realAudioOnlyBitmap" )  )

   561         {

   562             QVERIFY( mFileDetails->mRNFormat? val == true : val == false );

   563         }

   564         else if( mController->mLoader->mWidgets[i]->objectName() ==  QString( "partialAudioOnlyBitmap" )  )

   565         {

   566             QVERIFY( mFileDetails->mPartialPlayback? val == true : val == false );

   567         }

   568         else if( mController->mLoader->mWidgets[i]->objectName() ==  QString( "audioOnlyBitmap" )  )

   569         {

   570             QVERIFY( tvOutConnected? val == false : val == true );

   571         }

   572     }

   573 

   574     //

   575     // validate generateThumbNail()

   576     //

   577     if ( tvOutConnected )

   578     {

   579         QVERIFY( ( mController->mFileDetails->mPlaybackMode == EMPXVideoLocal )?

   580                    mController->mThumbNailState == EThumbNailRequsted :

   581                    mController->mThumbNailState == EThumbNailNotAvailable );

   582         QVERIFY( mController->mViewMode == EAudioOnlyView );

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

   584         QVERIFY( mController->mThumbnailManager->mThumbSize == ThumbnailManager::ThumbnailLarge );

   585         QVERIFY( mController->mThumbnailManager->mQuality == ThumbnailManager::OptimizeForPerformance );

   586         QVERIFY( mController->mViewTransitionIsGoingOn == false );

   587     }

   588     else if ( mController->mFileDetails->mVideoEnabled )

   589     {

   590         QVERIFY( mController->mViewTransitionIsGoingOn == true );

   591         QVERIFY( mController->mViewMode == EFullScreenView );

   592     }

   593     else if ( ! mController->mFileDetails->mVideoEnabled )

   594     {

   595         QVERIFY( mController->mViewTransitionIsGoingOn == false );

   596         QVERIFY( mController->mViewMode == EAudioOnlyView );

   597     }

   598 

   599 }

   600 

   601 // -------------------------------------------------------------------------------------------------

   602 // TestControlsController::testHandleEventTvOutDisconnected

   603 // -------------------------------------------------------------------------------------------------

   604 //

   605 void TestControlsController::testHandleEventTvOutDisconnected()

   606 {

   607     MPX_DEBUG(_L("TestControlsController::testHandleEventTvOutDisconnected()") );

   608 

   609     init();

   610 

   611     //

   612     // TV-Out Disconnected, value = true

   613     //

   614     mController->handleEvent( EControlCmdTvOutDisconnected, true );

   615     verifyHandleEventTvOutResult( false, true );

   616 

   617     //

   618     // TV-Out Disconnected, value = false

   619     //

   620     mController->handleEvent( EControlCmdTvOutDisconnected, false );

   621     verifyHandleEventTvOutResult( false, false );

   622 

   623     cleanup();

   624 }

   625 

   626 // -------------------------------------------------------------------------------------------------

   627 // TestControlsController::testHandleEventHandleErrors

   628 // -------------------------------------------------------------------------------------------------

   629 //

   630 void TestControlsController::testHandleEventHandleErrors()

   631 {

   632     MPX_DEBUG(_L("TestControlsController::testHandleEventHandleErrors()") );

   633 

   634     init();

   635 

   636     //

   637     // handle error

   638     //

   639     mController->handleEvent( EControlCmdHandleErrors, 0 );

   640 

   641     QVERIFY( mController->mThumbNailState == EThumbNailEmpty );

   642     QVERIFY( mController->mState == EPbStateNotInitialised );

   643     QVERIFY( mController->mViewMode == EFullScreenView );

   644 

   645     cleanup();

   646 }

   647 

   648 // -------------------------------------------------------------------------------------------------

   649 // TestControlsController::testHandleEventShowVolumeControls

   650 // -------------------------------------------------------------------------------------------------

   651 //

   652 void TestControlsController::testHandleEventShowVolumeControls()

   653 {

   654     MPX_DEBUG(_L("TestControlsController::testHandleEventShowVolumeControls()") );

   655 

   656     init();

   657 

   658     mController->handleEvent( EControlCmdShowVolumeControls, 0 );

   659 

   660     QVERIFY( mController->mVolumeControl->mVisible == true );

   661 

   662     cleanup();

   663 }

   664 

   665 // -------------------------------------------------------------------------------------------------

   666 // TestControlsController::testHandleCommand

   667 // -------------------------------------------------------------------------------------------------

   668 //

   669 void TestControlsController::testHandleCommand()

   670 {

   671     MPX_DEBUG(_L("TestControlsController::testHandleCommand()") );

   672 

   673     init();

   674 

   675     mController->handleCommand( EMPXPbvCmdSetPosition, 0 );

   676     QVERIFY( mViewWrapper->mProperty == EPbPropertyPosition );

   677 

   678     mController->handleCommand( EMPXPbvCmdSetVolume, 0 );

   679     QVERIFY( mViewWrapper->mProperty == EPbPropertyVolume );

   680 

   681     mController->handleCommand( EMPXPbvCmdPlay, 0 );

   682     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPlay );

   683 

   684     mController->handleCommand( EMPXPbvCmdPause, 0 );

   685     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPause );

   686 

   687     mController->handleCommand( EMPXPbvCmdPlayPause, 0 );

   688     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPlayPause );

   689 

   690     mController->handleCommand( EMPXPbvCmdStop, 0 );

   691     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdStop );

   692 

   693     mController->handleCommand( EMPXPbvCmdClose, 0 );

   694     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdClose );

   695 

   696     mController->handleCommand( EMPXPbvCmdMute, 0 );

   697     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdMute );

   698 

   699     mController->handleCommand( EMPXPbvCmdUnMute, 0 );

   700     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdUnMute );

   701 

   702     mController->handleCommand( EMPXPbvCmdChangeAspectRatio, 0 );

   703     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdChangeAspectRatio );

   704 

   705     mController->handleCommand( EMPXPbvCmdNaturalAspectRatio, 0 );

   706     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdNaturalAspectRatio );

   707 

   708     mController->handleCommand( EMPXPbvCmdZoomAspectRatio, 0 );

   709     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdZoomAspectRatio );

   710 

   711     mController->handleCommand( EMPXPbvCmdStretchAspectRatio, 0 );

   712     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdStretchAspectRatio );

   713 

   714     mController->handleCommand( EMPXPbvCmdSeekForward, 0 );

   715     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdSeekForward );

   716 

   717     mController->handleCommand( EMPXPbvCmdSeekBackward, 0 );

   718     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdSeekBackward );

   719 

   720     mController->handleCommand( EMPXPbvCmdEndSeek, 0 );

   721     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdEndSeek );

   722 

   723     mController->handleCommand( EMPXPbvCmdNextListItem, 0 );

   724     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdNextListItem );

   725 

   726     mController->handleCommand( EMPXPbvCmdPreviousListItem, 0 );

   727     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPreviousListItem );

   728 

   729     mController->handleCommand( EMPXPbvCmdDecreaseVolume, 0 );

   730     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdDecreaseVolume );

   731 

   732     mController->handleCommand( EMPXPbvCmdIncreaseVolume, 0 );

   733     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdIncreaseVolume );

   734 

   735     mController->handleCommand( EMPXPbvCmdPosition, 0 );

   736     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPosition );

   737 

   738     mController->handleCommand( EMPXPbvCmdSave, 0 );

   739     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdSave );

   740 

   741     mController->handleCommand( EMPXPbvCmdResetControls, 0 );

   742     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdResetControls );

   743 

   744     mController->handleCommand( EMPXPbvCmdShortPressForward, 0 );

   745     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdShortPressForward );

   746 

   747     mController->handleCommand( EMPXPbvCmdShortPressBackward, 0 );

   748     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdShortPressBackward );

   749 

   750     mController->handleCommand( EMPXPbvCmdShowFileDetails, 0 );

   751     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdShowFileDetails );

   752 

   753     mController->handleCommand( EMPXPbvCmdEndOfClip, 0 );

   754     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdEndOfClip );

   755 

   756     mController->handleCommand( EMPXPbvCmdCustomPause, 0 );

   757     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdCustomPause );

   758 

   759     mController->handleCommand( EMPXPbvCmdCustomPlay, 0 );

   760     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdCustomPlay );

   761 

   762     mController->handleCommand( EMPXPbvCmdExit, 0 );

   763     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdExit );

   764 

   765     mController->handleCommand( EMPXPbvLaunchDRMDetails, 0 );

   766     QVERIFY( mViewWrapper->mCommandId == EMPXPbvLaunchDRMDetails );

   767 

   768     mController->handleCommand( EMPXPbvSurfaceCreated, 0 );

   769     QVERIFY( mViewWrapper->mCommandId == EMPXPbvSurfaceCreated );

   770 

   771     cleanup();

   772 }

   773 

   774 // -------------------------------------------------------------------------------------------------

   775 // TestControlsController::testHandleTappedOnScreen

   776 // -------------------------------------------------------------------------------------------------

   777 //

   778 void TestControlsController::testHandleTappedOnScreen()

   779 {

   780     MPX_DEBUG(_L("TestControlsController::testHandleTappedOnScreen()") );

   781 

   782     init();

   783     mController->mOrientation = Qt::Horizontal;

   784     connect( this, SIGNAL( commandSignal() ), mController, SLOT( handleTappedOnScreen() ) );

   785 

   786     //

   787     // 1. Test full screen view

   788     //

   789     mController->mViewMode = EFullScreenView;

   790 

   791     //

   792     // (1a) playing state

   793     //

   794     mController->mState = EPbStatePlaying;

   795     emit commandSignal();

   796 

   797     QVERIFY( mController->mControlsTimer->isActive() == true );

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

   799     {

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

   801     }

   802 

   803     //

   804     // (1b) pause state

   805     //

   806     mController->mState = EPbStatePaused;

   807     emit commandSignal();

   808 

   809     QVERIFY( mController->mControlsTimer->isActive() == false );

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

   811     {

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

   813     }

   814 

   815 

   816     //

   817     // 2. Test details screen view

   818     //

   819     mController->mViewMode = EDetailsView;

   820 

   821     //

   822     // (2a) non-pausable stream, currently in 'playing' state

   823     //

   824     mController->mFileDetails->mPausableStream = false;

   825     mController->mViewWrapper->HandleCommandL( EMPXPbvCmdSetVolume ); // set a random cmd

   826     mController->mState = EPbStatePlaying;

   827 

   828     emit commandSignal();

   829     QVERIFY( mController->mViewWrapper->mCommandId == EMPXPbvCmdSetVolume );

   830 

   831     //

   832     // (2b) pausable stream, currently in 'playing' state

   833     //

   834     mController->mFileDetails->mPausableStream = true;

   835     mController->mViewWrapper->HandleCommandL( EMPXPbvCmdChangeAspectRatio ); // set a random cmd

   836     mController->mState = EPbStatePlaying;

   837 

   838     emit commandSignal();

   839     QVERIFY( mController->mViewWrapper->mCommandId == EMPXPbvCmdPlayPause );

   840 

   841     //

   842     // (2c) non-pausable stream, currently in 'paused' state

   843     //

   844     mController->mFileDetails->mPausableStream = false;

   845     mController->mViewWrapper->HandleCommandL( EMPXPbvCmdEndSeek ); // set a random cmd

   846     mController->mState = EPbStatePaused;

   847 

   848     emit commandSignal();

   849     QVERIFY( mController->mViewWrapper->mCommandId == EMPXPbvCmdPlayPause );

   850 

   851     //

   852     // (2d) pausable stream, currently in 'paused' state

   853     //

   854     mController->mFileDetails->mPausableStream = true;

   855     mController->mViewWrapper->HandleCommandL( EMPXPbvCmdSave ); // set a random cmd

   856     mController->mState = EPbStatePaused;

   857 

   858     emit commandSignal();

   859     QVERIFY( mController->mViewWrapper->mCommandId == EMPXPbvCmdPlayPause );

   860 

   861     //

   862     // disconnect signal and clean up

   863     //

   864     disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( handleTappedOnScreen() ) );

   865     cleanup();

   866 }

   867 

   868 // -------------------------------------------------------------------------------------------------

   869 // TestControlsController::testUpdateVideoRectDone

   870 // -------------------------------------------------------------------------------------------------

   871 //

   872 void TestControlsController::testUpdateVideoRectDone()

   873 {

   874     MPX_DEBUG(_L("TestControlsController::testUpdateVideoRectDone()") );

   875 

   876     init();

   877 

   878     mController->updateVideoRectDone();

   879 

   880     //

   881     // default is full-screen

   882     //

   883     QVERIFY( mController->mControlsConfig->mState == EControlCmdFullScreenViewOpened );

   884 

   885     //

   886     // validate Details view

   887     //

   888     mController->mViewMode = EDetailsView;

   889 

   890     mController->updateVideoRectDone();

   891 

   892     QVERIFY( mController->mControlsConfig->mState == EControlCmdDetailsViewOpened );

   893 

   894     cleanup();

   895 }

   896 

   897 // -------------------------------------------------------------------------------------------------

   898 // TestControlsController::testIsAttachOperation

   899 // -------------------------------------------------------------------------------------------------

   900 //

   901 void TestControlsController::testIsAttachOperation()

   902 {

   903     MPX_DEBUG(_L("TestControlsController::testIsAttachOperation()") );

   904 

   905     //

   906     // get access to XQServiceUtilXtra stub

   907     //

   908     XQServiceUtilXtra* extraUtil = XQServiceUtilXtra::instance();

   909 

   910     //

   911     // set service enable

   912     //

   913     extraUtil->setCurrentService( true );

   914 

   915     //

   916     // initialize controlscontroller

   917     //

   918     init();

   919 

   920     //

   921     // verify 'mIsAttachOperation' flag is enabled

   922     //

   923     QVERIFY( mController->mIsAttachOperation == true );

   924 

   925     //

   926     // clean up

   927     //

   928     cleanup();

   929 

   930     //

   931     // set service disable

   932     //

   933     extraUtil->setCurrentService( false );

   934 

   935     //

   936     // initialize controlscontroller

   937     //

   938     init();

   939 

   940     //

   941     // verify 'mIsAttachOperation' flag is disabled

   942     //

   943     QVERIFY( mController->mIsAttachOperation == false );

   944 

   945     //

   946     // clean up

   947     //

   948     cleanup();

   949 

   950     //

   951     // dereference extraUtil count

   952     //

   953     extraUtil->decreaseReferenceCount();

   954 }

   955 

   956 // -------------------------------------------------------------------------------------------------

   957 // TestControlsController::testslot_skipToNextVideoItem

   958 // -------------------------------------------------------------------------------------------------

   959 //

   960 void TestControlsController::testslot_skipToNextVideoItem()

   961 {

   962     MPX_DEBUG(_L("TestControlsController::testslot_skipToNextVideoItem()") );

   963 

   964     init();

   965 

   966     connect( this, SIGNAL( commandSignal() ), mController, SLOT( skipToNextVideoItem() ) );

   967 

   968     //

   969     // If we are not in full screen view, ignore

   970     //

   971     mViewWrapper->mCommandId = EMPXPbvCmdPosition;

   972     mController->mViewMode = EDetailsView;

   973 

   974     emit commandSignal();

   975 

   976     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPosition );

   977 

   978     //

   979     // If we are in full screen view, issue EMPXPbvCmdNextListItem;

   980     //

   981     mController->mViewMode = EFullScreenView;

   982 

   983     emit commandSignal();

   984 

   985     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdNextListItem );

   986 

   987     disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( skipToNextVideoItem() ) );

   988 

   989     cleanup();

   990 }

   991 

   992 // -------------------------------------------------------------------------------------------------

   993 // TestControlsController::testslot_skipToPreviousVideoItem

   994 // -------------------------------------------------------------------------------------------------

   995 //

   996 void TestControlsController::testslot_skipToPreviousVideoItem()

   997 {

   998     MPX_DEBUG(_L("TestControlsController::testslot_skipToPreviousVideoItem()") );

   999 

  1000     init();

  1001 

  1002     connect( this, SIGNAL( commandSignal() ), mController, SLOT( skipToPreviousVideoItem() ) );

  1003 

  1004     //

  1005     // If we are not in full screen view, ignore

  1006     //

  1007     mViewWrapper->mCommandId = EMPXPbvCmdPosition;

  1008     mController->mViewMode = EDetailsView;

  1009 

  1010     emit commandSignal();

  1011 

  1012     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPosition );

  1013 

  1014     //

  1015     // If we are in full screen view, issue EMPXPbvCmdPreviousListItem

  1016     //

  1017     mController->mViewMode = EFullScreenView;

  1018 

  1019     emit commandSignal();

  1020 

  1021     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPreviousListItem );

  1022 

  1023     disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( skipToPreviousVideoItem() ) );

  1024 

  1025     cleanup();

  1026 }

  1027 

  1028 // -------------------------------------------------------------------------------------------------

  1029 // TestControlsController::testslot_attachVideo

  1030 // -------------------------------------------------------------------------------------------------

  1031 //

  1032 void TestControlsController::testslot_attachVideo()

  1033 {

  1034     MPX_DEBUG(_L("TestControlsController::testslot_attachVideo()") );

  1035 

  1036     //

  1037     // get access to XQServiceUtilXtra stub to enable XQServiceUtil::isService() method

  1038     //

  1039     XQServiceUtilXtra* extraUtil = XQServiceUtilXtra::instance();

  1040 

  1041     //

  1042     // set service enable

  1043     //

  1044     extraUtil->setCurrentService( true );

  1045 

  1046     //

  1047     // initialize controlscontroller

  1048     //

  1049     init();

  1050 

  1051     //

  1052     // verify view closePlaybackView() slot is not yet called

  1053     //

  1054     QVERIFY( mController->mView->mViewClosed == false );

  1055 

  1056     //

  1057     // connect signal with controller attachVideo() slot

  1058     //

  1059     bool res = connect( this, SIGNAL( commandSignal() ), mController, SLOT( attachVideo() ) );

  1060 

  1061     //

  1062     // emit signal, this will in turns invoke videoservices itemSelected() slot

  1063     //

  1064     emit commandSignal();

  1065 

  1066     //

  1067     // verify view closePlaybackView() slot is called

  1068     //

  1069     QVERIFY( mController->mView->mViewClosed == true );

  1070 

  1071     //

  1072     // verify videoservices itemSelected() slot is called

  1073     //

  1074     QVERIFY( mController->mVideoServices->mItemSelected == true );

  1075 

  1076     //

  1077     // disconnect signal

  1078     //

  1079     disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( attachVideo() ) );

  1080 

  1081     //

  1082     // clean up

  1083     //

  1084     cleanup();

  1085 

  1086     //

  1087     // dereference extraUtil count

  1088     //

  1089     extraUtil->decreaseReferenceCount();

  1090 

  1091 }

  1092 

  1093 // -------------------------------------------------------------------------------------------------

  1094 // TestControlsController::testslot_sendVideo

  1095 // -------------------------------------------------------------------------------------------------

  1096 //

  1097 void TestControlsController::testslot_sendVideo()

  1098 {

  1099     MPX_DEBUG(_L("TestControlsController::testslot_sendVideo()") );

  1100 

  1101     //

  1102     // initialize controlscontroller

  1103     //

  1104     init();

  1105 

  1106     //

  1107     // connect signal with controller sendVideoo() slot

  1108     //

  1109     bool res = connect( this, SIGNAL( commandSignal() ), mController, SLOT( sendVideo() ) );

  1110 

  1111     //

  1112     // emit signal, this will in turns invoke mController sendVideo() slot

  1113     //

  1114     emit commandSignal();

  1115 

  1116     //

  1117     // verify command EMPXPbvCmdClose has been issued

  1118     //

  1119     QVERIFY( mViewWrapper->mCommandId == EMPXPbvCmdPause );

  1120 

  1121     //

  1122     // disconnect signal

  1123     //

  1124     disconnect( this, SIGNAL( commandSignal() ), mController, SLOT( sendVideo() ) );

  1125 

  1126     //

  1127     // clean up

  1128     //

  1129     cleanup();

  1130 }

  1131 

  1132 // -------------------------------------------------------------------------------------------------

  1133 // TestControlsController::testslot_handleOrientationChanged

  1134 // -------------------------------------------------------------------------------------------------