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:  10 %

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

    31 #include "mpxcommonvideoplaybackview.hrh"

    32 #include "testmpxvideoplaybackcontrolscontroller.h"

    33 #include "hbvideobaseplaybackview.h"

    34 #include "mpxvideoplaybackviewfiledetails.h"

    35 #include "mpxvideoviewwrapper.h"

    36 #include "mpxvideoplaybackfullscreencontrol.h"

    37 #include "mpxvideoplaybackcontrolconfiguration.h"

    38 #include "thumbnailmanager_qt.h"

    39 #include "mpxvideoplaybackdocumentloader.h"

    40 #include "hbvolumesliderpopup.h"

    41 #include "videoservices.h"

    42 #include "xqserviceutilxtra.h"

    43 

    44 #define private public

    45 #include "mpxvideoplaybackcontrolscontroller.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     TestMPXVideoPlaybackControlsController tv;

    59 

    60     char *pass[3];

    61     pass[0] = argv[0];

    62     pass[1] = "-o";

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

    64 

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

    66 

    67     return res;

    68 }

    69 

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

    71 // init

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

    73 //

    74 void TestMPXVideoPlaybackControlsController::init()

    75 {

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

    77 

    78     mBaseVideoView = new HbVideoBasePlaybackView();

    79 

    80     if ( ! mFileDetails )

    81     {

    82         mFileDetails   = new QMPXVideoPlaybackViewFileDetails();

    83     }

    84     mViewWrapper   = CMPXVideoViewWrapper::NewL( mBaseVideoView );

    85     mController    = new QMPXVideoPlaybackControlsController( mBaseVideoView,

    86                                                               mViewWrapper,

    87                                                               mFileDetails );

    88 }

    89 

    90 // ---------------------------------------------------------------------------

    91 // cleanup

    92 // ---------------------------------------------------------------------------

    93 //

    94 void TestMPXVideoPlaybackControlsController::cleanup()

    95 {

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

    97 

    98     delete mController;

    99     mController = NULL;

   100 

   101     delete mFileDetails;

   102     mFileDetails = NULL;

   103 

   104     delete mViewWrapper;

   105     mViewWrapper = NULL;

   106 

   107     delete mBaseVideoView;

   108     mBaseVideoView = NULL;

   109 }

   110 

   111 // -------------------------------------------------------------------------------------------------

   112 // TestMPXVideoPlaybackControlsController::testAddFileDetails

   113 // -------------------------------------------------------------------------------------------------

   114 //

   115 void TestMPXVideoPlaybackControlsController::testAddFileDetails()

   116 {

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

   118 

   119     //

   120     // local real media with no video

   121     //

   122     mFileDetails = new QMPXVideoPlaybackViewFileDetails();

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

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

   125 

   126     init();

   127 

   128     mController->addFileDetails( mFileDetails );

   129 

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

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

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

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

   134 

   135     cleanup();

   136 

   137     //

   138     // local 3GPP media with video-only

   139     //

   140     mFileDetails = new QMPXVideoPlaybackViewFileDetails();

   141 

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

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

   144     mFileDetails->mVideoEnabled = true;

   145     mFileDetails->mTvOutConnected = true;

   146 

   147     init();

   148 

   149     mController->mViewMode = EFullScreenView;

   150     QFileInfo videoOnlyFile( mFileDetails->mClipName );

   151 

   152     mController->addFileDetails( mFileDetails );

   153 

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

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

   156 

   157     //

   158     // validate 'TvOutConnected'

   159     //

   160     verifyHandleEventTvOutResult(true, true);

   161 

   162     //

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

   164     //

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

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

   167 

   168     //

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

   170     //

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

   172     {

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

   174         {

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

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

   177             break;

   178         }

   179     }

   180     cleanup();

   181 

   182     //

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

   184     //

   185     mFileDetails = new QMPXVideoPlaybackViewFileDetails();

   186 

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

   188     mFileDetails->mPlaybackMode = EMPXVideoStreaming;

   189     mFileDetails->mTvOutConnected = false;

   190     mFileDetails->mAudioEnabled = true;

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

   192 

   193     init();

   194 

   195     mController->addFileDetails( mFileDetails );

   196 

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

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

   199 

   200     //

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

   202     //

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

   204     {

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

   206         {

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

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

   209             break;

   210         }

   211     }

   212 

   213     cleanup();

   214 }

   215 

   216 // -------------------------------------------------------------------------------------------------

   217 // TestMPXVideoPlaybackControlsController::testHandleEventSetPosition

   218 // -------------------------------------------------------------------------------------------------

   219 //

   220 void TestMPXVideoPlaybackControlsController::testHandleEventSetPosition()

   221 {

   222     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventSetPosition()"));

   223 

   224     init();

   225     int value = 20000;

   226 

   227     mController->handleEvent( EMPXControlCmdSetPosition, value );

   228 

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

   230 

   231     cleanup();

   232 }

   233 

   234 // -------------------------------------------------------------------------------------------------

   235 // TestMPXVideoPlaybackControlsController::testHandleEventSetDuration

   236 // -------------------------------------------------------------------------------------------------

   237 //

   238 void TestMPXVideoPlaybackControlsController::testHandleEventSetDuration()

   239 {

   240     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventSetDuration()"));

   241 

   242     init();

   243     int value = 30000;

   244 

   245     mController->handleEvent( EMPXControlCmdSetDuration, value );

   246 

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

   248 

   249     cleanup();

   250 }

   251 

   252 // -------------------------------------------------------------------------------------------------

   253 // TestMPXVideoPlaybackControlsController::testHandleEventStateChanged

   254 // -------------------------------------------------------------------------------------------------

   255 //

   256 void TestMPXVideoPlaybackControlsController::testHandleEventStateChanged()

   257 {

   258     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventStateChanged()"));

   259 

   260     init();

   261     TMPXVideoPlaybackControlCommandIds event = EMPXControlCmdStateChanged;

   262     mController->mOrientation = Qt::Horizontal;

   263 

   264     //

   265     // state change (EPbStateInitialising)

   266     //

   267     int value = EPbStateInitialising;

   268     mController->handleEvent( event, value );

   269     verifyHandleEventStateChangedResult( value );

   270 

   271     //

   272     // state change (EPbStateBuffering)

   273     //

   274     value = EPbStateBuffering;

   275     mController->handleEvent( event, value );

   276     verifyHandleEventStateChangedResult( value );

   277 

   278     //

   279     // state change (EPbStatePlaying)

   280     //

   281     value = EPbStatePlaying;

   282     mController->handleEvent( event, value );

   283     verifyHandleEventStateChangedResult( value );

   284 

   285     //

   286     // state change (EPbStatePaused)

   287     //

   288     value = EPbStatePaused;

   289     mController->handleEvent( event, value );

   290     verifyHandleEventStateChangedResult( value );

   291 

   292     //

   293     // state change (EPbStateNotInitialised)

   294     //

   295     value = EPbStateNotInitialised;

   296     mController->handleEvent( event, value );

   297     verifyHandleEventStateChangedResult( value );

   298 

   299     //

   300     // state change (EPbStateStopped)

   301     //

   302     value = EPbStateStopped;

   303     mController->handleEvent( event, value );

   304     verifyHandleEventStateChangedResult( value );

   305 

   306     //

   307     // state change (EPbStateSeekingForward)

   308     //

   309     value = EPbStateSeekingForward;

   310     mController->handleEvent( event, value );

   311     verifyHandleEventStateChangedResult( value );

   312 

   313     //

   314     // state change (EPbStateSeekingBackward)

   315     //

   316     value = EPbStateSeekingBackward;

   317     mController->handleEvent( event, value );

   318     verifyHandleEventStateChangedResult( value );

   319 

   320     //

   321     // state change (EPbStateShuttingDown)

   322     //

   323     value = EPbStateShuttingDown;

   324     mController->handleEvent( event, value );

   325     verifyHandleEventStateChangedResult( value );

   326 

   327     //

   328     // state change (EPbStateDownloading)

   329     //

   330     value = EPbStateDownloading;

   331     mController->handleEvent( event, value );

   332     verifyHandleEventStateChangedResult( value );

   333 

   334     //

   335     // state change (EPbStatePluginSeeking)

   336     //

   337     value = EPbStatePluginSeeking;

   338     mController->handleEvent( event, value );

   339     verifyHandleEventStateChangedResult( value );

   340 

   341     cleanup();

   342 }

   343 

   344 // -------------------------------------------------------------------------------------------------

   345 // TestMPXVideoPlaybackControlsController::verifyHandleEventStateChangedResult

   346 // -------------------------------------------------------------------------------------------------

   347 //

   348 void TestMPXVideoPlaybackControlsController::verifyHandleEventStateChangedResult( int value )

   349 {

   350     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::verifyHandleEventStateChangedResult()"));

   351 

   352     mController->mOrientation = Qt::Horizontal;

   353 

   354     if ( value == EPbStateInitialised &&

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

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

   357     {

   358         QVERIFY( mController->mControlsConfig->mState == EMPXControlCmdPluginInitialized );

   359     }

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

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

   362               value == EPbStateNotInitialised )

   363     {

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

   365         {

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

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

   368         }

   369     }

   370     else

   371     {

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

   373     }

   374 }

   375 

   376 // -------------------------------------------------------------------------------------------------

   377 // TestMPXVideoPlaybackControlsController::testHandleEventSetVolume

   378 // -------------------------------------------------------------------------------------------------

   379 //

   380 void TestMPXVideoPlaybackControlsController::testHandleEventSetVolume()

   381 {

   382     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventSetVolume()"));

   383 

   384     init();

   385     int value = 40;

   386 

   387     mController->handleEvent( EMPXControlCmdSetVolume, value );

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

   389 

   390     cleanup();

   391 }

   392 

   393 // -------------------------------------------------------------------------------------------------

   394 // TestMPXVideoPlaybackControlsController::testHandleEventSetAspectRatio

   395 // -------------------------------------------------------------------------------------------------

   396 //

   397 void TestMPXVideoPlaybackControlsController::testHandleEventSetAspectRatio()

   398 {

   399     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventSetAspectRatio()"));

   400 

   401     init();

   402     int numScalingType = 5;

   403 

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

   405     {

   406         mController->handleEvent( EMPXControlCmdSetAspectRatio, i );

   407 

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

   409     }

   410 

   411     cleanup();

   412 }

   413 

   414 // -------------------------------------------------------------------------------------------------

   415 // TestMPXVideoPlaybackControlsController::testHandleEventSetDownloadSize

   416 // -------------------------------------------------------------------------------------------------

   417 //

   418 void TestMPXVideoPlaybackControlsController::testHandleEventSetDownloadSize()

   419 {

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

   421 

   422     init();

   423     int value = 50;

   424 

   425     mController->handleEvent( EMPXControlCmdSetDownloadSize, value );

   426 

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

   428 

   429     cleanup();

   430 }

   431 

   432 // -------------------------------------------------------------------------------------------------

   433 // TestMPXVideoPlaybackControlsController::testHandleEventDownloadUpdated

   434 // -------------------------------------------------------------------------------------------------

   435 //

   436 void TestMPXVideoPlaybackControlsController::testHandleEventDownloadUpdated()

   437 {

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

   439 

   440     init();

   441     int value = 55;

   442 

   443     mController->handleEvent( EMPXControlCmdDownloadUpdated, value );

   444 

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

   446 

   447     cleanup();

   448 }

   449 

   450 // -------------------------------------------------------------------------------------------------

   451 // TestMPXVideoPlaybackControlsController::testHandleEventDownloadComplete

   452 // -------------------------------------------------------------------------------------------------

   453 //

   454 void TestMPXVideoPlaybackControlsController::testHandleEventDownloadComplete()

   455 {

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

   457 

   458     init();

   459     int value = 60;

   460 

   461     mController->handleEvent( EMPXControlCmdDownloadComplete, value );

   462 

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

   464 

   465     cleanup();

   466 }

   467 

   468 // -------------------------------------------------------------------------------------------------

   469 // TestMPXVideoPlaybackControlsController::testHandleEventSetDownloadPaused

   470 // -------------------------------------------------------------------------------------------------

   471 //

   472 void TestMPXVideoPlaybackControlsController::testHandleEventSetDownloadPaused()

   473 {

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

   475 

   476     init();

   477     int value = 0;

   478 

   479     mController->handleEvent( EMPXControlCmdSetDownloadPaused, value );

   480 

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

   482 

   483     cleanup();

   484 }

   485 

   486 // -------------------------------------------------------------------------------------------------

   487 // TestMPXVideoPlaybackControlsController::testHandleEventClearDownloadPaused

   488 // -------------------------------------------------------------------------------------------------

   489 //

   490 void TestMPXVideoPlaybackControlsController::testHandleEventClearDownloadPaused()

   491 {

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

   493 

   494     init();

   495     int value = 0;

   496 

   497     mController->handleEvent( EMPXControlCmdClearDownloadPaused, value );

   498 

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

   500 

   501     cleanup();

   502 }

   503 

   504 // -------------------------------------------------------------------------------------------------

   505 // TestMPXVideoPlaybackControlsController::testHandleEventTvOutConnected

   506 // -------------------------------------------------------------------------------------------------

   507 //

   508 void TestMPXVideoPlaybackControlsController::testHandleEventTvOutConnected()

   509 {

   510     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventTvOutConnected()") );

   511 

   512     init();

   513 

   514     //

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

   516     //

   517     mController->handleEvent( EMPXControlCmdTvOutConnected, true );

   518     verifyHandleEventTvOutResult( true, true );

   519 

   520     //

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

   522     //

   523     mController->handleEvent( EMPXControlCmdTvOutConnected, false );

   524     verifyHandleEventTvOutResult( true, false );

   525 

   526     //

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

   528     //

   529     mController->mFileDetails->mPlaybackMode = EMPXVideoStreaming;

   530     mController->handleEvent( EMPXControlCmdTvOutConnected, false );

   531     verifyHandleEventTvOutResult( true, false );

   532 

   533     cleanup();

   534 }

   535 

   536 // -------------------------------------------------------------------------------------------------

   537 // TestMPXVideoPlaybackControlsController::verifyHandleEventTvOutResult

   538 // -------------------------------------------------------------------------------------------------

   539 //

   540 void TestMPXVideoPlaybackControlsController::verifyHandleEventTvOutResult( bool tvOutConnected,

   541         bool value )

   542 {

   543     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::verifyHandleEventTvOutResult(%d,%d)"),

   544             tvOutConnected, value );

   545 

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

   547 

   548     //

   549     // validate setDefaultBitmap()

   550     //

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

   552     {

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

   554 

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

   556         {

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

   558         }

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

   560         {

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

   562         }

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

   564         {

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

   566         }

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

   568         {

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

   570         }

   571     }

   572 

   573     //

   574     // validate generateThumbNail()

   575     //

   576     if ( tvOutConnected )

   577     {

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

   579                    mController->mThumbNailState == EThumbNailRequsted :

   580                    mController->mThumbNailState == EThumbNailNotAvailable );

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

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

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

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

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

   586     }

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

   588     {

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

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

   591     }

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

   593     {

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

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

   596     }

   597 

   598 }

   599 

   600 // -------------------------------------------------------------------------------------------------

   601 // TestMPXVideoPlaybackControlsController::testHandleEventTvOutDisconnected

   602 // -------------------------------------------------------------------------------------------------

   603 //

   604 void TestMPXVideoPlaybackControlsController::testHandleEventTvOutDisconnected()

   605 {

   606     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventTvOutDisconnected()") );

   607 

   608     init();

   609 

   610     //

   611     // TV-Out Disconnected, value = true

   612     //

   613     mController->handleEvent( EMPXControlCmdTvOutDisconnected, true );

   614     verifyHandleEventTvOutResult( false, true );

   615 

   616     //

   617     // TV-Out Disconnected, value = false

   618     //

   619     mController->handleEvent( EMPXControlCmdTvOutDisconnected, false );

   620     verifyHandleEventTvOutResult( false, false );

   621 

   622     cleanup();

   623 }

   624 

   625 // -------------------------------------------------------------------------------------------------

   626 // TestMPXVideoPlaybackControlsController::testHandleEventHandleErrors

   627 // -------------------------------------------------------------------------------------------------

   628 //

   629 void TestMPXVideoPlaybackControlsController::testHandleEventHandleErrors()

   630 {

   631     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventHandleErrors()") );

   632 

   633     init();

   634 

   635     //

   636     // handle error

   637     //

   638     mController->handleEvent( EMPXControlCmdHandleErrors, 0 );

   639 

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

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

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

   643 

   644     cleanup();

   645 }

   646 

   647 // -------------------------------------------------------------------------------------------------

   648 // TestMPXVideoPlaybackControlsController::testHandleEventShowVolumeControls

   649 // -------------------------------------------------------------------------------------------------

   650 //

   651 void TestMPXVideoPlaybackControlsController::testHandleEventShowVolumeControls()

   652 {

   653     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleEventShowVolumeControls()") );

   654 

   655     init();

   656 

   657     mController->handleEvent( EMPXControlCmdShowVolumeControls, 0 );

   658 

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

   660 

   661     cleanup();

   662 }

   663 

   664 // -------------------------------------------------------------------------------------------------

   665 // TestMPXVideoPlaybackControlsController::testHandleCommand

   666 // -------------------------------------------------------------------------------------------------

   667 //

   668 void TestMPXVideoPlaybackControlsController::testHandleCommand()

   669 {

   670     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleCommand()") );

   671 

   672     init();

   673 

   674     mController->handleCommand( EMPXPbvCmdSetPosition, 0 );

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

   676 

   677     mController->handleCommand( EMPXPbvCmdSetVolume, 0 );

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

   679 

   680     mController->handleCommand( EMPXPbvCmdPlay, 0 );

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

   682 

   683     mController->handleCommand( EMPXPbvCmdPause, 0 );

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

   685 

   686     mController->handleCommand( EMPXPbvCmdPlayPause, 0 );

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

   688 

   689     mController->handleCommand( EMPXPbvCmdStop, 0 );

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

   691 

   692     mController->handleCommand( EMPXPbvCmdClose, 0 );

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

   694 

   695     mController->handleCommand( EMPXPbvCmdMute, 0 );

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

   697 

   698     mController->handleCommand( EMPXPbvCmdUnMute, 0 );

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

   700 

   701     mController->handleCommand( EMPXPbvCmdChangeAspectRatio, 0 );

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

   703 

   704     mController->handleCommand( EMPXPbvCmdNaturalAspectRatio, 0 );

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

   706 

   707     mController->handleCommand( EMPXPbvCmdZoomAspectRatio, 0 );

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

   709 

   710     mController->handleCommand( EMPXPbvCmdStretchAspectRatio, 0 );

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

   712 

   713     mController->handleCommand( EMPXPbvCmdSeekForward, 0 );

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

   715 

   716     mController->handleCommand( EMPXPbvCmdSeekBackward, 0 );

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

   718 

   719     mController->handleCommand( EMPXPbvCmdEndSeek, 0 );

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

   721 

   722     mController->handleCommand( EMPXPbvCmdNextListItem, 0 );

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

   724 

   725     mController->handleCommand( EMPXPbvCmdPreviousListItem, 0 );

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

   727 

   728     mController->handleCommand( EMPXPbvCmdDecreaseVolume, 0 );

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

   730 

   731     mController->handleCommand( EMPXPbvCmdIncreaseVolume, 0 );

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

   733 

   734     mController->handleCommand( EMPXPbvCmdPosition, 0 );

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

   736 

   737     mController->handleCommand( EMPXPbvCmdSave, 0 );

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

   739 

   740     mController->handleCommand( EMPXPbvCmdResetControls, 0 );

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

   742 

   743     mController->handleCommand( EMPXPbvCmdShortPressForward, 0 );

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

   745 

   746     mController->handleCommand( EMPXPbvCmdShortPressBackward, 0 );

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

   748 

   749     mController->handleCommand( EMPXPbvCmdShowFileDetails, 0 );

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

   751 

   752     mController->handleCommand( EMPXPbvCmdEndOfClip, 0 );

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

   754 

   755     mController->handleCommand( EMPXPbvCmdCustomPause, 0 );

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

   757 

   758     mController->handleCommand( EMPXPbvCmdCustomPlay, 0 );

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

   760 

   761     mController->handleCommand( EMPXPbvCmdExit, 0 );

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

   763 

   764     mController->handleCommand( EMPXPbvLaunchDRMDetails, 0 );

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

   766 

   767     mController->handleCommand( EMPXPbvSurfaceCreated, 0 );

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

   769 

   770     cleanup();

   771 }

   772 

   773 // -------------------------------------------------------------------------------------------------

   774 // TestMPXVideoPlaybackControlsController::testHandleTappedOnScreen

   775 // -------------------------------------------------------------------------------------------------

   776 //

   777 void TestMPXVideoPlaybackControlsController::testHandleTappedOnScreen()

   778 {

   779     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testHandleTappedOnScreen()") );

   780 

   781     init();

   782     mController->mOrientation = Qt::Horizontal;

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

   784 

   785     //

   786     // 1. Test full screen view

   787     //

   788     mController->mViewMode = EFullScreenView;

   789 

   790     //

   791     // playing state

   792     //

   793     mController->mState = EPbStatePlaying;

   794     emit commandSignal();

   795 

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

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

   798     {

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

   800     }

   801 

   802     //

   803     // pause state

   804     //

   805     mController->mState = EPbStatePaused;

   806     emit commandSignal();

   807 

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

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

   810     {

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

   812     }

   813 

   814 

   815     //

   816     // 2. Test details screen view

   817     //

   818     mController->mViewMode = EDetailsView;

   819 

   820     emit commandSignal();

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

   822 

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

   824     cleanup();

   825 }

   826 

   827 // -------------------------------------------------------------------------------------------------

   828 // TestMPXVideoPlaybackControlsController::testUpdateVideoRectDone

   829 // -------------------------------------------------------------------------------------------------

   830 //

   831 void TestMPXVideoPlaybackControlsController::testUpdateVideoRectDone()

   832 {

   833     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testUpdateVideoRectDone()") );

   834 

   835     init();

   836 

   837     mController->updateVideoRectDone();

   838 

   839     //

   840     // default is full-screen

   841     //

   842     QVERIFY( mController->mControlsConfig->mState == EMPXControlCmdFullScreenViewOpened );

   843 

   844     //

   845     // validate Details view

   846     //

   847     mController->mViewMode = EDetailsView;

   848 

   849     mController->updateVideoRectDone();

   850 

   851     QVERIFY( mController->mControlsConfig->mState == EMPXControlCmdDetailsViewOpened );

   852 

   853     cleanup();

   854 }

   855 

   856 // -------------------------------------------------------------------------------------------------

   857 // TestMPXVideoPlaybackControlsController::testIsAttachOperation

   858 // -------------------------------------------------------------------------------------------------

   859 //

   860 void TestMPXVideoPlaybackControlsController::testIsAttachOperation()

   861 {

   862     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testIsAttachOperation()") );

   863 

   864     //

   865     // get access to XQServiceUtilXtra stub

   866     //

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

   868 

   869     //

   870     // set service enable

   871     //

   872     extraUtil->setCurrentService( true );

   873 

   874     //

   875     // initialize controlscontroller

   876     //

   877     init();

   878 

   879     //

   880     // verify 'mIsAttachOperation' flag is enabled

   881     //

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

   883 

   884     //

   885     // clean up

   886     //

   887     cleanup();

   888 

   889     //

   890     // set service disable

   891     //

   892     extraUtil->setCurrentService( false );

   893 

   894     //

   895     // initialize controlscontroller

   896     //

   897     init();

   898 

   899     //

   900     // verify 'mIsAttachOperation' flag is disabled

   901     //

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

   903 

   904     //

   905     // clean up

   906     //

   907     cleanup();

   908 

   909     //

   910     // dereference extraUtil count

   911     //

   912     extraUtil->decreaseReferenceCount();

   913 }

   914 

   915 // -------------------------------------------------------------------------------------------------

   916 // TestMPXVideoPlaybackControlsController::testslot_skipToNextVideoItem

   917 // -------------------------------------------------------------------------------------------------

   918 //

   919 void TestMPXVideoPlaybackControlsController::testslot_skipToNextVideoItem()

   920 {

   921     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testslot_skipToNextVideoItem()") );

   922 

   923     init();

   924 

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

   926 

   927     //

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

   929     //

   930     mViewWrapper->mCommandId = EMPXPbvCmdPosition;

   931     mController->mViewMode = EDetailsView;

   932 

   933     emit commandSignal();

   934 

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

   936 

   937     //

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

   939     //

   940     mController->mViewMode = EFullScreenView;

   941 

   942     emit commandSignal();

   943 

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

   945 

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

   947 

   948     cleanup();

   949 }

   950 

   951 // -------------------------------------------------------------------------------------------------

   952 // TestMPXVideoPlaybackControlsController::testslot_skipToPreviousVideoItem

   953 // -------------------------------------------------------------------------------------------------

   954 //

   955 void TestMPXVideoPlaybackControlsController::testslot_skipToPreviousVideoItem()

   956 {

   957     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testslot_skipToPreviousVideoItem()") );

   958 

   959     init();

   960 

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

   962 

   963     //

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

   965     //

   966     mViewWrapper->mCommandId = EMPXPbvCmdPosition;

   967     mController->mViewMode = EDetailsView;

   968 

   969     emit commandSignal();

   970 

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

   972 

   973     //

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

   975     //

   976     mController->mViewMode = EFullScreenView;

   977 

   978     emit commandSignal();

   979 

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

   981 

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

   983 

   984     cleanup();

   985 }

   986 

   987 // -------------------------------------------------------------------------------------------------

   988 // TestMPXVideoPlaybackControlsController::testslot_attachVideo

   989 // -------------------------------------------------------------------------------------------------

   990 //

   991 void TestMPXVideoPlaybackControlsController::testslot_attachVideo()

   992 {

   993     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testslot_attachVideo()") );

   994 

   995     //

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

   997     //

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

   999 

  1000     //

  1001     // set service enable

  1002     //

  1003     extraUtil->setCurrentService( true );

  1004 

  1005     //

  1006     // initialize controlscontroller

  1007     //

  1008     init();

  1009 

  1010     //

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

  1012     //

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

  1014 

  1015     //

  1016     // connect signal with controller attachVideo() slot

  1017     //

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

  1019 

  1020     //

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

  1022     //

  1023     emit commandSignal();

  1024 

  1025     //

  1026     // verify view closePlaybackView() slot is called

  1027     //

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

  1029 

  1030     //

  1031     // verify videoservices itemSelected() slot is called

  1032     //

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

  1034 

  1035     //

  1036     // disconnect signal

  1037     //

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

  1039 

  1040     //

  1041     // clean up

  1042     //

  1043     cleanup();

  1044 

  1045     //

  1046     // dereference extraUtil count

  1047     //

  1048     extraUtil->decreaseReferenceCount();

  1049 

  1050 }

  1051 

  1052 // -------------------------------------------------------------------------------------------------

  1053 // TestMPXVideoPlaybackControlsController::testslot_sendVideo

  1054 // -------------------------------------------------------------------------------------------------

  1055 //

  1056 void TestMPXVideoPlaybackControlsController::testslot_sendVideo()

  1057 {

  1058     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testslot_sendVideo()") );

  1059 

  1060     //

  1061     // initialize controlscontroller

  1062     //

  1063     init();

  1064 

  1065     //

  1066     // connect signal with controller sendVideoo() slot

  1067     //

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

  1069 

  1070     //

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

  1072     //

  1073     emit commandSignal();

  1074 

  1075     //

  1076     // verify command EMPXPbvCmdClose has been issued

  1077     //

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

  1079 

  1080     //

  1081     // disconnect signal

  1082     //

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

  1084 

  1085     //

  1086     // clean up

  1087     //

  1088     cleanup();

  1089 }

  1090 

  1091 // -------------------------------------------------------------------------------------------------

  1092 // TestMPXVideoPlaybackControlsController::testslot_handleOrientationChanged

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

  1094 //

  1095 void TestMPXVideoPlaybackControlsController::testslot_handleOrientationChanged()

  1096 {

  1097     MPX_DEBUG(_L("TestMPXVideoPlaybackControlsController::testslot_handleOrientationChanged()") );

  1098 

  1099     //

  1100     // initialize controlscontroller

  1101     //

  1102     init();

  1103 

  1104     //

  1105     // connect signal with controller handleOrientationChanged() slot

  1106     //

  1107     bool res = connect( this, SIGNAL( commandSignal( Qt::Orientation ) ),

  1108                         mController, SLOT( handleOrientationChanged( Qt::Orientation ) ) );

  1109 

  1110     //

  1111     // emit signal, this will in turns invoke mController handleOrientationChanged() slot

  1112     //

  1113     mController->mOrientation = Qt::Vertical;

  1114     mController->mState = EPbStatePlaying;

  1115 

  1116     emit commandSignal( Qt::Horizontal );

  1117 

  1118     QVERIFY( mController->mOrientation == Qt::Horizontal );

  1119 

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

  1121     {

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

  1123     }

  1124 

  1125     //

  1126     // disconnect signal

  1127     //

  1128     disconnect( this, SIGNAL( commandSignal( Qt::Orientation ) ),

  1129                 mController, SLOT( handleOrientationChanged( Qt::Orientation ) ) );

  1130 

  1131     //

  1132     // clean up

  1133     //

  1134     cleanup();