1 /**

     2 * Copyright (c) 2009 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 VideoSortFilterProxyModel

    15 *

    16 */

    17 

    18 // Version : %version: 13 %

    19 

    20 #include <e32err.h>

    21 #include <w32std.h>

    22 

    23 #include <mmf/common/mmferrors.h>

    24 #include <caf/caferr.h>

    25 

    26 #include <mpxvideoplaybackdefs.h>

    27 #include <mpxhbvideocommondefs.h>

    28 

    29 #include <hbapplication.h>

    30 #include <hbinstance.h>

    31 #include <qgraphicssceneevent>

    32 #include <QDebug>

    33 

    34 #include "videoplaybackviewfiledetails.h"

    35 #include "mpxcommonvideoplaybackview.hrh"

    36 

    37 #include "testvideoplaybackview.h"

    38 #include "mpxvideoviewwrapper.h"

    39 #include "hbtapgesture.h"

    40 #include "hbpangesture.h"

    41 #include "videoactivitystate.h"

    42 

    43 #define private public

    44 #define protected public

    45 #include "videoplaybackview.h"

    46 #include "videobaseplaybackview.h"

    47 #undef protected

    48 #undef private

    49 

    50 

    51 // ---------------------------------------------------------------------------

    52 // main

    53 // ---------------------------------------------------------------------------

    54 //

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

    56 {

    57     HbApplication app(argc, argv);

    58     HbMainWindow window;

    59 

    60     TestVideoPlaybackView tv;

    61 

    62     char *pass[3];

    63     pass[0] = argv[0];

    64     pass[1] = "-o";

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

    66 

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

    68 

    69     return res;

    70 }

    71 

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

    73 // init

    74 // ---------------------------------------------------------------------------

    75 //

    76 void TestVideoPlaybackView::init()

    77 {

    78     mVideoView = new VideoPlaybackView();

    79 }

    80 

    81 // ---------------------------------------------------------------------------

    82 // cleanup

    83 // ---------------------------------------------------------------------------

    84 //

    85 void TestVideoPlaybackView::cleanup()

    86 {

    87     delete mVideoView;

    88     mVideoView = NULL;

    89 }

    90 

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

    92 // setup

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

    94 //

    95 void TestVideoPlaybackView::setup()

    96 {

    97     init();

    98     mVideoView->handleActivateView();

    99 }

   100 

   101 // -------------------------------------------------------------------------------------------------

   102 //   TestVideoPlaybackView::testHandleActivateView()

   103 // -------------------------------------------------------------------------------------------------

   104 //

   105 void TestVideoPlaybackView::testHandleActivateView()

   106 {

   107     init();

   108     mVideoView->handleActivateView();

   109 

   110     QVERIFY( mVideoView->mVideoMpxWrapper->iMediaRequested == true );

   111     QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mBitRate, 16000 );

   112     QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mTitle, QString("Test Video Title") );

   113 

   114     cleanup();

   115 }

   116 

   117 // -------------------------------------------------------------------------------------------------

   118 //   TestVideoPlaybackView::testHandlePluginError()

   119 // -------------------------------------------------------------------------------------------------

   120 //

   121 void TestVideoPlaybackView::testHandlePluginError()

   122 {

   123     //

   124     // playback view is closed after displaying these error notes

   125     //

   126     verifyHandlePluginError( KErrNotSupported );

   127     verifyHandlePluginError( KErrUnknown );

   128     verifyHandlePluginError( KErrMMDecoder );

   129     verifyHandlePluginError( KErrCorrupt );

   130     verifyHandlePluginError( KErrTooBig );

   131     verifyHandlePluginError( KErrMMInvalidProtocol );

   132     verifyHandlePluginError( KErrMMInvalidURL );

   133     verifyHandlePluginError( KErrArgument );

   134     verifyHandlePluginError( KErrSessionClosed );

   135     verifyHandlePluginError( KErrTimedOut );

   136     verifyHandlePluginError( KErrNotFound );

   137     verifyHandlePluginError( KErrMMNotEnoughBandwidth );

   138     verifyHandlePluginError( KErrDisconnected );

   139     verifyHandlePluginError( KErrMMProxyServer );

   140     verifyHandlePluginError( KErrCouldNotConnect );

   141     verifyHandlePluginError( KErrAbort );

   142     verifyHandlePluginError( KErrCancel );

   143     verifyHandlePluginError( KErrMMDRMNotAuthorized );

   144     verifyHandlePluginError( KErrCANoRights );

   145     verifyHandlePluginError( KErrCANoPermission );

   146 

   147     //

   148     // playback view remains open after displaying these error notes

   149     //

   150     verifyHandlePluginError( KMPXVideoCallOngoingError, false );

   151     verifyHandlePluginError( KMPXVideoPlayOver2GDuringVoiceCallError, false );

   152 

   153     //

   154     // default error case, playback view is closed after displaying error note

   155     //

   156     verifyHandlePluginError( KErrGeneral );

   157 }

   158 

   159 // -------------------------------------------------------------------------------------------------

   160 //   TestVideoPlaybackView::testShowDialog()

   161 // -------------------------------------------------------------------------------------------------

   162 //

   163 void TestVideoPlaybackView::testShowDialog()

   164 {

   165     //

   166     // construct and activate playback view

   167     //

   168     setup();

   169 

   170     //

   171     // ensure that playback view is currently activated

   172     //

   173     QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );

   174 

   175     //

   176     // test showDialog() method

   177     //

   178     mVideoView->showDialog( "test error msg" );

   179 

   180     //

   181     // connect and emit signal for handleClosePopupDialog() slot

   182     //

   183     connect( this, SIGNAL( commandSignal() ), mVideoView, SLOT( handleClosePopupDialog() ) );

   184     emit commandSignal();

   185 

   186     //

   187     // verify that playback view is properly closed

   188     //

   189     QVERIFY( mVideoView->mTimerForClosingView->isActive() );

   190 

   191     //

   192     // disconnect signal for handleClosePopupDialog() slot

   193     //

   194     disconnect( this, SIGNAL( commandSignal() ), mVideoView, SLOT( handleClosePopupDialog() ) );

   195 

   196     //

   197     // destruct playback view

   198     //

   199     cleanup();

   200 }

   201 

   202 // -------------------------------------------------------------------------------------------------

   203 //   TestVideoPlaybackView::testGetWindow()

   204 // -------------------------------------------------------------------------------------------------

   205 //

   206 void TestVideoPlaybackView::testGetWindow()

   207 {

   208     setup();

   209 

   210     QVERIFY( mVideoView->getWindow() != NULL );

   211 

   212     cleanup();

   213 }

   214 

   215 // -------------------------------------------------------------------------------------------------

   216 //   TestVideoPlaybackView::testIssuePlayCommand()

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

   218 //

   219 void TestVideoPlaybackView::testIssuePlayCommand()

   220 {

   221     setup();

   222 

   223     mVideoView->issuePlayCommand();

   224 

   225     //JAM remove

   226     QVERIFY( mVideoView->isEnabled() );

   227 

   228     cleanup();

   229 }

   230 

   231 // -------------------------------------------------------------------------------------------------

   232 //   TestVideoPlaybackView::testEventFilter()

   233 // -------------------------------------------------------------------------------------------------

   234 //

   235 void TestVideoPlaybackView::testEventFilter()

   236 {

   237     setup();

   238 

   239     //

   240     // ensure default foreground is false

   241     //

   242     QCOMPARE( mVideoView->mVideoMpxWrapper->iForeground, 0 );

   243 

   244     //

   245     // declare foreground/background event

   246     //

   247     QEvent* appActivate   = new QEvent( QEvent::ApplicationActivate );

   248     QEvent* appDeactivate = new QEvent( QEvent::ApplicationDeactivate );

   249 

   250     //

   251     // verify the returned value (consumed) of VideoBasePlaybackView::event()

   252     // for QEvent::ApplicationActivate is false

   253     //

   254     QVERIFY( ! mVideoView->eventFilter( NULL, appActivate ) );

   255 

   256     //

   257     // verify view is in foreground

   258     //

   259     QCOMPARE( mVideoView->mVideoMpxWrapper->iForeground, 1 );

   260 

   261     //

   262     // verify the returned value (consumed) of VideoBasePlaybackView::event()

   263     // for QEvent::ApplicationDeactivate is false

   264     //

   265     QVERIFY( ! mVideoView->eventFilter( NULL, appDeactivate ) );

   266 

   267     //

   268     // verify view is in background

   269     //

   270     QCOMPARE( mVideoView->mVideoMpxWrapper->iForeground, 0 );

   271 

   272     //

   273     // clean up

   274     //

   275     if ( appActivate )

   276     {

   277         delete appActivate;

   278         appActivate = NULL;

   279     }

   280 

   281     if ( appDeactivate )

   282     {

   283         delete appDeactivate;

   284         appDeactivate = NULL;

   285     }

   286 

   287     cleanup();

   288 }

   289 

   290 // -------------------------------------------------------------------------------------------------

   291 //   TestVideoPlaybackView::testClosePlaybackView()

   292 // -------------------------------------------------------------------------------------------------

   293 //

   294 void TestVideoPlaybackView::testClosePlaybackView()

   295 {

   296     setup();

   297 

   298     QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );

   299 

   300     mVideoView->closePlaybackView();

   301 

   302     QVERIFY( mVideoView->mTimerForClosingView->isActive() );

   303 

   304     cleanup();

   305 }

   306 

   307 // -------------------------------------------------------------------------------------------------

   308 //   TestVideoPlaybackView::testHandlePdlStateChange()

   309 // -------------------------------------------------------------------------------------------------

   310 //

   311 void TestVideoPlaybackView::testHandlePdlStateChange()

   312 {

   313     setup();

   314 

   315     QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mClipName, QString("testClip.3gp") );

   316 

   317     mVideoView->handlePdlStateChange( 0 );

   318 

   319     QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mClipName, QString("testClip.3gp") );

   320 

   321     cleanup();

   322 }

   323 

   324 // -------------------------------------------------------------------------------------------------

   325 //   TestVideoPlaybackView::testHandleStoppedStateNoPrevView()

   326 // -------------------------------------------------------------------------------------------------

   327 //

   328 void TestVideoPlaybackView::testHandleStoppedStateNoPrevView()

   329 {

   330     setup();

   331 

   332     QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );

   333     mVideoView->handleStoppedState();

   334 

   335     QVERIFY( mVideoView->mTimerForClosingView->isActive() );

   336 

   337     cleanup();

   338 }

   339 

   340 // -------------------------------------------------------------------------------------------------

   341 //   TestVideoPlaybackView::testHandleStoppedStatePrevView()

   342 // -------------------------------------------------------------------------------------------------

   343 //

   344 void TestVideoPlaybackView::testHandleStoppedStatePrevView()

   345 {

   346     setup();

   347 

   348     mVideoView->handleStoppedState();

   349 

   350     QVERIFY( mVideoView->mTimerForClosingView->isActive() );

   351 

   352     cleanup();

   353 

   354 }

   355 

   356 // -------------------------------------------------------------------------------------------------

   357 //   TestVideoPlaybackView::testHandleBackNoPrevView()

   358 // -------------------------------------------------------------------------------------------------

   359 //

   360 void TestVideoPlaybackView::testHandleBackNoPrevView()

   361 {

   362     setup();

   363 

   364     QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );

   365     mVideoView->handleBack();

   366 

   367     QVERIFY( mVideoView->mTimerForClosingView->isActive() );

   368 

   369     cleanup();

   370 

   371 }

   372 

   373 // -------------------------------------------------------------------------------------------------

   374 //   TestVideoPlaybackView::testHandleBackPrevView()

   375 // -------------------------------------------------------------------------------------------------

   376 //

   377 void TestVideoPlaybackView::testHandleBackPrevView()

   378 {

   379     setup();

   380 

   381     mVideoView->handleBack();

   382 

   383     QVERIFY( mVideoView->mTimerForClosingView->isActive() );

   384 

   385     cleanup();

   386 }

   387 

   388 // -------------------------------------------------------------------------------------------------

   389 //   TestVideoPlaybackView::testHandleSoftkeyback()

   390 // -------------------------------------------------------------------------------------------------

   391 //

   392 void TestVideoPlaybackView::testHandleSoftkeyback()

   393 {

   394     setup();

   395 

   396     mVideoView->handleSoftkeyBack();

   397 

   398     QVERIFY( mVideoView->mTimerForClosingView->isActive() );

   399 

   400     cleanup();

   401 }

   402 

   403 // -------------------------------------------------------------------------------------------------

   404 //   TestVideoPlaybackView::testDoClosePlayer()

   405 // -------------------------------------------------------------------------------------------------

   406 //

   407 void TestVideoPlaybackView::testDoClosePlayer()

   408 {

   409     // quits app - which can be problematic for the qvptestrunner app

   410 

   411 //    setup();

   412 //

   413 //    mVideoView->handleActivateView();

   414 //

   415 //    mVideoView->doClosePlayer();

   416 //

   417 //    cleanup();

   418 

   419 }

   420 

   421 // -------------------------------------------------------------------------------------------------

   422 //   TestVideoPlaybackView::testHandleDeactivateView()

   423 // -------------------------------------------------------------------------------------------------

   424 //

   425 void TestVideoPlaybackView::testHandleDeactivateView()

   426 {

   427     setup();

   428 

   429     mVideoView->handleDeactivateView();

   430 

   431     QVERIFY( mVideoView->mVideoMpxWrapper == NULL );

   432 

   433     cleanup();

   434 }

   435 

   436 // -------------------------------------------------------------------------------------------------

   437 //   TestVideoPlaybackView::verifyHandlePluginError()

   438 // -------------------------------------------------------------------------------------------------

   439 //

   440 void TestVideoPlaybackView::verifyHandlePluginError( TInt error, bool closeView )

   441 {

   442     //

   443     // construct and activate playback view

   444     //

   445     setup();

   446 

   447     //

   448     // ensure that playback view is currently open

   449     //

   450     QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );

   451 

   452     //

   453     // test handlePluginError() method

   454     //

   455     mVideoView->handlePluginError( error );

   456 

   457     //

   458     // close playback view after error note has been launched

   459     //

   460     if ( closeView )

   461     {

   462         //

   463         // connect and emit signal for handleClosePopupDialog() slot

   464         //

   465         connect( this, SIGNAL( commandSignal() ), mVideoView, SLOT( handleClosePopupDialog() ) );

   466         emit commandSignal();

   467 

   468         //

   469         // verify that playback view is properly closed

   470         //

   471         QVERIFY( mVideoView->mTimerForClosingView->isActive() );

   472 

   473         //

   474         // disconnect signal for handleClosePopupDialog() slot

   475         //

   476         disconnect( this, SIGNAL( commandSignal() ), mVideoView, SLOT( handleClosePopupDialog() ) );

   477     }

   478     else

   479     {

   480         //

   481         // verify that playback view is still open after error note has been launched

   482         //

   483         QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );

   484     }

   485 

   486     //

   487     // destruct playback view

   488     //

   489     cleanup();

   490 }

   491 

   492 // -------------------------------------------------------------------------------------------------

   493 //   TestVideoPlaybackView::testGestureEvent()

   494 // -------------------------------------------------------------------------------------------------

   495 //

   496 void TestVideoPlaybackView::testGestureEvent()

   497 {

   498     setup();

   499 

   500     //

   501     // 1. Test tap gesture

   502     //

   503     QList<QGesture *> list;

   504     HbTapGesture *tapGesture = new HbTapGesture();

   505     list.append( tapGesture );

   506     QGestureEvent* event = new QGestureEvent( list );

   507 

   508     //

   509     // connect to tappedOnScreen() signal and record its emission

   510     //

   511     QSignalSpy spy( mVideoView, SIGNAL( tappedOnScreen() ) );

   512 

   513     //

   514     // ensure signal has not been emitted yet

   515     //

   516     QCOMPARE( spy.count(), 0 );

   517 

   518     //

   519     // With GestureStarted

   520     //

   521     tapGesture->mState = Qt::GestureStarted;

   522     mVideoView->gestureEvent( event );

   523 

   524     //

   525     // ensure signal hasn't been emitted and its emission count is not incremented

   526     //

   527     QCOMPARE( spy.count(), 0 );

   528 

   529     //

   530     // With GestureFinished

   531     //

   532     tapGesture->mState = Qt::GestureFinished;

   533     mVideoView->gestureEvent( event );

   534 

   535     //

   536     // ensure signal has been emitted and its emission count is incremented

   537     //

   538     QCOMPARE( spy.count(), 1 );

   539 

   540     //

   541     // clean up

   542     //

   543     spy.clear();

   544 

   545     list.clear();

   546 

   547     if ( tapGesture )

   548     {

   549         delete tapGesture;

   550         tapGesture = NULL;

   551     }

   552 

   553     if ( event )

   554     {

   555         delete event;

   556         event = NULL;

   557     }

   558 

   559     //

   560     // 2. Test pan gesture

   561     //

   562     HbPanGesture *panGesture = new HbPanGesture();

   563     list.append( panGesture );

   564     event = new QGestureEvent( list );

   565 

   566     //

   567     // connect to pannedToRight() signal and record its emission

   568     //

   569     QSignalSpy spy1( mVideoView, SIGNAL( pannedToRight() ) );

   570 

   571     //

   572     // ensure signal has not been emitted yet

   573     //

   574     QCOMPARE( spy1.count(), 0 );

   575 

   576     //

   577     // Test pan gesture With GestureStarted

   578     //

   579     panGesture->mState = Qt::GestureStarted;

   580     mVideoView->gestureEvent( event );

   581 

   582     //

   583     // ensure signal has not been emitted yet

   584     //

   585     QCOMPARE( spy1.count(), 0 );

   586 

   587     //

   588     // Test pan gesture with GestureFinished

   589     //

   590     panGesture->mState = Qt::GestureFinished;

   591     panGesture->mSceneDelta = QPointF( 5, 0 );

   592     mVideoView->gestureEvent( event );

   593 

   594     //

   595     // ensure signal has been emitted

   596     //

   597     QCOMPARE( spy1.count(), 1 );

   598     spy1.clear();

   599 

   600     //

   601     // Test pan gesture with GestureFinished

   602     //

   603 

   604     //

   605     // connect to pannedToRight() signal and record its emission

   606     //

   607     QSignalSpy spy2( mVideoView, SIGNAL( pannedToLeft() ) );

   608 

   609     //

   610     // ensure signal has not been emitted yet

   611     //

   612     QCOMPARE( spy2.count(), 0 );

   613 

   614     panGesture->mState = Qt::GestureFinished;

   615     panGesture->mSceneDelta = QPointF( -5, 0 );

   616     mVideoView->gestureEvent( event );

   617 

   618     //

   619     // ensure signal has not been emitted yet

   620     //

   621     QCOMPARE( spy2.count(), 1 );

   622 

   623     //

   624     // clean up

   625     //

   626     spy2.clear();

   627     list.clear();

   628 

   629     if ( panGesture )

   630     {

   631         delete panGesture;

   632         panGesture = NULL;

   633     }

   634 

   635     if ( event )

   636     {

   637         delete event;

   638         event = NULL;

   639     }

   640 

   641     cleanup();

   642 }

   643 

   644 // -------------------------------------------------------------------------------------------------

   645 //   TestVideoPlaybackView::testReactivationAfterPriorTermination()

   646 // -------------------------------------------------------------------------------------------------

   647 //

   648 void TestVideoPlaybackView::testReactivationAfterPriorTermination()

   649 {

   650     QVariant data = int( 10 );

   651     VideoActivityState::instance().setActivityData(data, KEY_LAST_PLAY_POSITION_ID);

   652     

   653     data = int ( MpxHbVideoCommon::PlaybackView );

   654     VideoActivityState::instance().setActivityData(data, KEY_VIEWPLUGIN_TYPE);  

   655     

   656     init();

   657     mVideoView->handleActivateView();

   658 

   659     QVERIFY( mVideoView->mVideoMpxWrapper->iMediaRequested == true );

   660     QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mBitRate, 16000 );

   661     QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mTitle, QString("Test Video Title") );

   662     

   663     QCOMPARE( mVideoView->mLastPlayPosition, 10);

   664 

   665     cleanup();            

   666 }

   667 

   668 // End of file