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

    19 

    20 #include <e32err.h>

    21 #include <w32std.h>

    22 

    23 #include <hbapplication.h>

    24 #include <hbinstance.h>

    25 #include <QDebug>

    26 

    27 #include <mpxplaybackframeworkdefs.h>

    28 #include <mpxplaybackutility.h>

    29 #include <mpxcommonvideoplaybackview.hrh>

    30 #include <mpxmessagegeneraldefs.h>

    31 #include <mpxplaybackmessage.h>

    32 #include <mpxmediageneraldefs.h>

    33 #include <mpxmediavideodefs.h>

    34 

    35 #include "testmpxvideoviewwrapper.h"

    36 

    37 #include "../stub/inc/hbvideobaseplaybackview.h"

    38 #include "../stub/inc/mpxvideoplaybackviewfiledetails.h"

    39 #include "../stub/inc/mpxvideoplaybackdisplayhandler.h"

    40 #include "../stub/inc/mpxvideoplaybackcontrolscontroller.h"

    41 

    42 

    43 #define protected public

    44 #include "mpxvideoviewwrapper.h"

    45 #undef protected

    46 

    47 

    48 // ---------------------------------------------------------------------------

    49 // main

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

    51 //

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

    53 {

    54     HbApplication app(argc, argv);

    55     HbMainWindow window;

    56 

    57     TestMPXVideoViewWrapper tv;

    58 

    59     char *pass[3];

    60     pass[0] = argv[0];

    61     pass[1] = "-o";

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

    63 

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

    65 

    66     return res;

    67 }

    68 

    69 // ---------------------------------------------------------------------------

    70 // init

    71 // ---------------------------------------------------------------------------

    72 //

    73 void TestMPXVideoViewWrapper::init()

    74 {

    75     mBaseVideoView    = new HbVideoBasePlaybackView();

    76     TRAPD( err, mVideoViewWrapper = CMPXVideoViewWrapper::NewL( mBaseVideoView ) );

    77     QVERIFY( err == KErrNone );

    78 }

    79 

    80 // ---------------------------------------------------------------------------

    81 // cleanup

    82 // ---------------------------------------------------------------------------

    83 //

    84 void TestMPXVideoViewWrapper::cleanup()

    85 {

    86     if ( mVideoViewWrapper )

    87     {

    88         delete mVideoViewWrapper;

    89         mVideoViewWrapper = NULL;

    90     }

    91 

    92     if ( mBaseVideoView )

    93     {

    94         delete mBaseVideoView;

    95         mBaseVideoView = NULL;

    96     }

    97 }

    98 

    99 void TestMPXVideoViewWrapper::testRequestMedia()

   100 {

   101     init();

   102 

   103     TRAPD(err, mVideoViewWrapper->RequestMediaL());

   104     QVERIFY( err == KErrNone );

   105 

   106     QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaRequested );

   107 

   108     cleanup();

   109 }

   110 

   111 void TestMPXVideoViewWrapper::testIsLive()

   112 {

   113     init();

   114 

   115     TRAPD(err, mVideoViewWrapper->RequestMediaL());

   116     QVERIFY( err == KErrNone );

   117 

   118     mVideoViewWrapper->iFileDetails->mPlaybackMode = EMPXVideoLiveStreaming;

   119     QVERIFY( mVideoViewWrapper->IsLive() );

   120 

   121     mVideoViewWrapper->iFileDetails->mPlaybackMode = EMPXVideoLocal;

   122     QVERIFY( ! mVideoViewWrapper->IsLive() );

   123 

   124     cleanup();

   125 }

   126 

   127 void TestMPXVideoViewWrapper::testIsPlaylist()

   128 {

   129     init();

   130 

   131     mVideoViewWrapper->iPlaylistView = true;

   132     QVERIFY( mVideoViewWrapper->IsPlaylist() == true );

   133 

   134     mVideoViewWrapper->iPlaylistView = false;

   135     QVERIFY( mVideoViewWrapper->IsPlaylist() == false );

   136 

   137     cleanup();

   138 }

   139 

   140 void TestMPXVideoViewWrapper::testHandleCommand()

   141 {

   142     init();

   143 

   144     TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() );

   145     QVERIFY( errReqMedia == KErrNone );

   146 

   147     //

   148     // Test 'Play' command

   149     //

   150     TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) );

   151     QVERIFY( errHdlCmd == KErrNone );

   152     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

   153 

   154     //

   155     // Test 'Pause' command

   156     //

   157     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPause ) );

   158     QVERIFY( errHdlCmd == KErrNone );

   159     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPause );

   160 

   161     //

   162     // Test 'Close' command

   163     //

   164     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdClose ) );

   165     QVERIFY( errHdlCmd == KErrNone );

   166     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdClose );

   167 

   168     //

   169     // Test 'Seek Forward' command

   170     //

   171     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdSeekForward ) );

   172     QVERIFY( errHdlCmd == KErrNone );

   173     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStartVideoSeekingForward );

   174 

   175     //

   176     // Test 'Seek Backward' command

   177     //

   178     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdSeekBackward ) );

   179     QVERIFY( errHdlCmd == KErrNone );

   180     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStartVideoSeekingBackward );

   181 

   182     //

   183     // Test 'End Seek' command

   184     //

   185     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdEndSeek ) );

   186     QVERIFY( errHdlCmd == KErrNone );

   187     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStopVideoSeeking );

   188 

   189     //

   190     // Test 'PlayPause' command

   191     //

   192     mVideoViewWrapper->iPlaybackState = EPbStatePlaying;

   193     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlayPause ) );

   194     QVERIFY( errHdlCmd == KErrNone );

   195     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPause );

   196 

   197     mVideoViewWrapper->iPlaybackState = EPbStatePaused;

   198     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlayPause ) );

   199     QVERIFY( errHdlCmd == KErrNone );

   200     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

   201 

   202     //

   203     // Test 'Stop' command

   204     //

   205     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdStop ) );

   206     QVERIFY( errHdlCmd == KErrNone );

   207     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStop );

   208 

   209     //

   210     // Test 'Decrease Volume' command

   211     //

   212     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdDecreaseVolume ) );

   213     QVERIFY( errHdlCmd == KErrNone );

   214     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleDecreaseVolume );

   215 

   216     //

   217     // Test 'Increase Volume' command

   218     //

   219     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdIncreaseVolume ) );

   220     QVERIFY( errHdlCmd == KErrNone );

   221     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleIncreaseVolume );

   222 

   223     //

   224     // Test 'Natural Aspect Ratio' command

   225     //

   226     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdNaturalAspectRatio ) );

   227     QVERIFY( errHdlCmd == KErrNone );

   228     QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdNaturalAspectRatio );

   229 

   230     //

   231     // Test 'Zoom Aspect Ratio' command

   232     //

   233     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdZoomAspectRatio ) );

   234     QVERIFY( errHdlCmd == KErrNone );

   235     QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdZoomAspectRatio );

   236 

   237     //

   238     // Test 'Stretch Aspect Ratio' command

   239     //

   240     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdStretchAspectRatio ) );

   241     QVERIFY( errHdlCmd == KErrNone );

   242     QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdStretchAspectRatio );

   243 

   244     //

   245     // Test 'Mute' command

   246     //

   247     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdMute ) );

   248     QVERIFY( errHdlCmd == KErrNone );

   249     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdMuteVolume );

   250 

   251     //

   252     // Test 'Un-mute' command

   253     //

   254     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdUnMute ) );

   255     QVERIFY( errHdlCmd == KErrNone );

   256     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdUnMuteVolume );

   257 

   258     //

   259     // Test 'Short Press Backward' command

   260     //

   261     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdShortPressBackward ) );

   262     QVERIFY( errHdlCmd == KErrNone );

   263     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iProperty == EPbPropertyPosition );

   264 

   265     //

   266     // Test 'Reset Controls' command

   267     //

   268     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdResetControls ) );

   269     QVERIFY( errHdlCmd == KErrNone );

   270     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdInitView );

   271 

   272     //

   273     // Test 'Next List Item' command

   274     //

   275     mVideoViewWrapper->iPlaylistView = true;

   276     mVideoViewWrapper->iFileDetails->mMultiItemPlaylist = true;

   277     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdNextListItem ) );

   278     QVERIFY( errHdlCmd == KErrNone );

   279     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdNext );

   280 

   281     //

   282     // Test 'Previous List Item' command

   283     //

   284     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPreviousListItem ) );

   285     QVERIFY( errHdlCmd == KErrNone );

   286     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPrevious );

   287 

   288     //

   289     // Test 'End Of Clip' command

   290     //

   291     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdEndOfClip ) );

   292     QVERIFY( errHdlCmd == KErrNone );

   293     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdEndofClipReached );

   294 

   295     //

   296     // Test 'Custom Pause' command

   297     //

   298     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdCustomPause ) );

   299     QVERIFY( errHdlCmd == KErrNone );

   300     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdCustomPause );

   301 

   302     //

   303     // Test 'Custom Play' command

   304     //

   305     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdCustomPlay ) );

   306     QVERIFY( errHdlCmd == KErrNone );

   307     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdCustomPlay );

   308 

   309     //

   310     // Test 'RealOne Bitmap Timeout' command

   311     //

   312     mVideoViewWrapper->iMediaRequestStatus = MediaDelivered;

   313     TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdRealOneBitmapTimeout ) );

   314     QVERIFY( errHdlCmd == KErrNone );

   315     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

   316 

   317     cleanup();

   318 }

   319 

   320 void TestMPXVideoViewWrapper::testHandlePluginError()

   321 {

   322     init();

   323 

   324     TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL());

   325     QVERIFY( errReqMedia == KErrNone );

   326 

   327     mVideoViewWrapper->HandlePluginError( KErrNotSupported );

   328 

   329     QVERIFY( mVideoViewWrapper->iView->mCurrentError == KErrNotSupported );

   330 

   331     cleanup();

   332 }

   333 

   334 void TestMPXVideoViewWrapper::testHandlePlaybackMessage()

   335 {

   336     init();

   337 

   338     //***************************

   339     // Test Video Msg

   340     //***************************

   341     CMPXMessage* message = NULL;

   342     TRAP_IGNORE(

   343         message = CMPXMessage::NewL();

   344         message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMediaIdVideoPlayback );

   345         message->SetTObjectValueL<TMPXVideoPlaybackCommand>

   346                                             ( KMPXMediaVideoPlaybackCommand, EPbCmdTvOutEvent );

   347         message->SetTObjectValueL<TInt>( KMPXMediaVideoTvOutConnected, ETrue );

   348     );

   349     mVideoViewWrapper->HandlePlaybackMessage( message, KErrNone );

   350     QVERIFY( mVideoViewWrapper->iFileDetails->mTvOutConnected );

   351     if ( message )

   352     {

   353         delete message;

   354         message = NULL;

   355     }

   356 

   357     //***************************

   358     // Test General Msg

   359     //***************************

   360     TRAP_IGNORE(

   361         message = CMPXMessage::NewL();

   362         message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMessageGeneral );

   363         message->SetTObjectValueL<TInt>( KMPXMessageGeneralEvent, 28 );   // EReachedEndOfPlaylist = 28

   364         message->SetTObjectValueL<TInt>( KMPXMessageGeneralType, 0 );

   365         message->SetTObjectValueL<TInt>( KMPXMessageGeneralData, 0 );

   366     );

   367     mVideoViewWrapper->HandlePlaybackMessage( message, KErrNone );

   368     QVERIFY( ! mVideoViewWrapper->iView->mViewActive );

   369     if ( message )

   370     {

   371         delete message;

   372         message = NULL;

   373     }

   374 

   375     //***************************

   376     // Test Video Msg with err

   377     //***************************

   378     TRAP_IGNORE( message = CMPXMessage::NewL() );

   379     mVideoViewWrapper->HandlePlaybackMessage( message, KErrNotFound );

   380     QVERIFY( mVideoViewWrapper->iView->mCurrentError == KErrNotFound );

   381     if ( message )

   382     {

   383         delete message;

   384         message = NULL;

   385     }

   386 

   387     cleanup();

   388 }

   389 

   390 void TestMPXVideoViewWrapper::testSetProperty()

   391 {

   392     init();

   393 

   394     TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL()) ;

   395     QVERIFY( errReqMedia == KErrNone );

   396 

   397     TMPXPlaybackProperty property = EPbPropertyMute;

   398     TInt propertyValue = 1;

   399 

   400     TRAPD( errSetProp, mVideoViewWrapper->SetPropertyL( property, propertyValue ) );

   401     QVERIFY( errSetProp == KErrNone );

   402 

   403     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iProperty == property );

   404     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iPropertyValue == propertyValue );

   405 

   406     cleanup();

   407 }

   408 

   409 void TestMPXVideoViewWrapper::testHandleProperty()

   410 {

   411     init();

   412 

   413     TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL());

   414     QVERIFY( errReqMedia == KErrNone );

   415 

   416     //

   417     // Duration

   418     //

   419     int value = 5000;

   420     TRAPD(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyDuration, value, KErrNone ) );

   421     QVERIFY( errHdlProp == KErrNone );

   422 

   423     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetDuration );

   424     QVERIFY( mVideoViewWrapper->iControlsController->mValue == value );

   425 

   426     //

   427     // Position

   428     //

   429     value = 500;

   430 

   431     TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyPosition, value, KErrNone ) );

   432     QVERIFY( errHdlProp == KErrNone );

   433 

   434     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetPosition );

   435     QVERIFY( mVideoViewWrapper->iControlsController->mValue == value );

   436 

   437     //

   438     // Volume

   439     //

   440     value = 10;

   441 

   442     TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyVolume, value, KErrNone ) );

   443     QVERIFY( errHdlProp == KErrNone );

   444 

   445     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetVolume );

   446     QVERIFY( mVideoViewWrapper->iControlsController->mValue == value );

   447 

   448     //

   449     // Mute

   450     //

   451     value = 1;

   452 

   453     TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyMute, value, KErrNone ) );

   454     QVERIFY( errHdlProp == KErrNone );

   455 

   456     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetVolume );

   457     QVERIFY( mVideoViewWrapper->iControlsController->mValue == 0 );

   458 

   459     cleanup();

   460 }

   461 

   462 void TestMPXVideoViewWrapper::testRetrieveFileNameAndMode()

   463 {

   464     init();

   465 

   466     mVideoViewWrapper->iFileDetails->clearFileDetails();

   467 

   468     CMPXCommand* cmd = NULL;

   469 

   470     TRAP_IGNORE( cmd = CMPXCommand::NewL() );

   471 

   472     if ( cmd )

   473     {

   474         TRAPD(errRetFileName, mVideoViewWrapper->RetrieveFileNameAndModeL( cmd ) );

   475         QVERIFY( errRetFileName == KErrNone );

   476 

   477         QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdInitView );

   478 

   479         QCOMPARE( mVideoViewWrapper->iFileDetails->mClipName, QString("testClip.3gp"));

   480 

   481         delete cmd;

   482         cmd = NULL;

   483     }

   484 

   485     cleanup();

   486 }

   487 

   488 void TestMPXVideoViewWrapper::testActivateClosePlayerActiveObject()

   489 {

   490     init();

   491 

   492     mVideoViewWrapper->ActivateClosePlayerActiveObject();

   493 

   494     QVERIFY( mVideoViewWrapper->iCloseAO->IsActive() );

   495 

   496     cleanup();

   497 }

   498 

   499 void TestMPXVideoViewWrapper::testDoClosePlayer()

   500 {

   501     init();

   502 

   503     TRAPD(err, mVideoViewWrapper->DoClosePlayer());

   504     QVERIFY( err == KErrNone );

   505 

   506     QVERIFY( ! mVideoViewWrapper->iView->mViewActive );

   507 

   508     cleanup();

   509 }

   510 

   511 void TestMPXVideoViewWrapper::testSetAspectRatio()

   512 {

   513     init();

   514     TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() );

   515     QVERIFY( errReqMedia == KErrNone );

   516 

   517     TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdStretchAspectRatio ) );

   518     QVERIFY( errHdlCmd == KErrNone );

   519 

   520     QVERIFY( mVideoViewWrapper->iDisplayHandler->iAspectRatio == EMMFStretch );

   521 

   522     cleanup();

   523 }

   524 

   525 void TestMPXVideoViewWrapper::testIsAppInFront()

   526 {

   527     init();

   528 

   529     TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL());

   530     QVERIFY( errReqMedia == KErrNone );

   531 

   532     bool front = false;

   533     TRAPD( errIsAppInFrnt, front = mVideoViewWrapper->IsAppInFrontL() );

   534 

   535     QVERIFY( errIsAppInFrnt == KErrNone );

   536 

   537     cleanup();

   538 }

   539 

   540 void TestMPXVideoViewWrapper::testClosePlaybackView()

   541 {

   542     init();

   543 

   544     TRAPD(err, mVideoViewWrapper->ClosePlaybackViewL());

   545     QVERIFY( err == KErrNone );

   546 

   547     QVERIFY( ! mVideoViewWrapper->iView->mViewActive );

   548 

   549     cleanup();

   550 }

   551 

   552 void TestMPXVideoViewWrapper::testHandleVolumeCmd()

   553 {

   554     init();

   555 

   556     TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() );

   557     QVERIFY( errReqMedia == KErrNone );

   558 

   559     TRAPD( errIssuePlay, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) );

   560     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

   561     QVERIFY( errIssuePlay == KErrNone );

   562 

   563     TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdDecreaseVolume ) );

   564     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleDecreaseVolume );

   565     QVERIFY( errHdlCmd == KErrNone );

   566 

   567     QVERIFY( mVideoViewWrapper->iFileDetails->mAudioEnabled );

   568 

   569     cleanup();

   570 }

   571 

   572 void TestMPXVideoViewWrapper::testHandleShortPressBackward()

   573 {

   574     init();

   575 

   576     TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() );

   577     QVERIFY( errReqMedia == KErrNone );

   578 

   579     TRAPD( errIssuePlay, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) );

   580     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

   581     QVERIFY( errIssuePlay == KErrNone );

   582 

   583     TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdShortPressBackward ) );

   584     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iProperty == EPbPropertyPosition );

   585     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iPropertyValue == 0 );

   586 

   587     QVERIFY( errHdlCmd == KErrNone );

   588 

   589     cleanup();

   590 }

   591 

   592 void TestMPXVideoViewWrapper::testIssueVideoAppForegroundCmd()

   593 {

   594     init();

   595 

   596     TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() );

   597     QVERIFY( errReqMedia == KErrNone );

   598 

   599     TRAPD( errIssuePlay, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) );

   600     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

   601 

   602     QVERIFY( errIssuePlay == KErrNone );

   603 

   604     //

   605     // test foreground

   606     //

   607     TRAPD( errIssueVidAppFGCmd, mVideoViewWrapper->IssueVideoAppForegroundCmdL( ETrue ) );

   608     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleForeground );

   609     QVERIFY( errIssueVidAppFGCmd == KErrNone );

   610 

   611     //

   612     // test background

   613     //

   614     TRAP( errIssueVidAppFGCmd, mVideoViewWrapper->IssueVideoAppForegroundCmdL( EFalse ) );

   615     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleBackground );

   616     QVERIFY( errIssueVidAppFGCmd == KErrNone );

   617 

   618     cleanup();

   619 }

   620 

   621 void TestMPXVideoViewWrapper::testCreateControls()

   622 {

   623     init();

   624 

   625     TRAPD(err, mVideoViewWrapper->CreateControlsL());

   626     QVERIFY( err == KErrNone );

   627 

   628     QVERIFY( mVideoViewWrapper->iControlsController );

   629 

   630     cleanup();

   631 }

   632 

   633 void TestMPXVideoViewWrapper::testIsMultiItemPlaylist()

   634 {

   635     init();

   636 

   637     TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL());

   638     QVERIFY( errReqMedia == KErrNone );

   639 

   640     QVERIFY( ! mVideoViewWrapper->IsMultiItemPlaylist() );

   641 

   642     cleanup();

   643 }

   644 

   645 void TestMPXVideoViewWrapper::testUpdateVideoRect()

   646 {

   647     init();

   648 

   649     TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL());

   650     QVERIFY( errReqMedia == KErrNone );

   651 

   652     TRect rect( 0, 0, 50, 50 );

   653 

   654     mVideoViewWrapper->UpdateVideoRect(

   655         rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY, false );

   656 

   657     QVERIFY( rect == mVideoViewWrapper->iDisplayHandler->iRect );

   658 

   659     cleanup();

   660 }

   661 

   662 void TestMPXVideoViewWrapper::testUpdateVideoRectDone()

   663 {

   664     init();

   665 

   666     TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL());

   667     QVERIFY( errReqMedia == KErrNone );

   668 

   669     mVideoViewWrapper->UpdateVideoRectDone();

   670 

   671     cleanup();

   672 }

   673 

   674 void TestMPXVideoViewWrapper::testHandleBufferingState()

   675 {

   676     init();

   677 

   678     TRAPD(err, mVideoViewWrapper->HandleBufferingStateL());

   679     QVERIFY( err == KErrNone );

   680 

   681     cleanup();

   682 }

   683 

   684 void TestMPXVideoViewWrapper::testHandleVideoPlaybackMessage()

   685 {

   686     init();

   687 

   688     CMPXMessage* message = NULL;

   689     TRAP_IGNORE(

   690         message = CMPXMessage::NewL();

   691         message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMediaIdVideoPlayback );

   692         message->SetTObjectValueL<TMPXVideoPlaybackCommand>

   693                                             ( KMPXMediaVideoPlaybackCommand, EPbCmdPluginError );

   694         message->SetTObjectValueL<TInt>( KMPXMediaVideoError, KErrNotSupported );

   695     );

   696 

   697     mVideoViewWrapper->HandleVideoPlaybackMessage( message );

   698 

   699     QCOMPARE( mVideoViewWrapper->iView->mCurrentError, KErrNotSupported );

   700     if ( message )

   701     {

   702         delete message;

   703         message = NULL;

   704     }

   705 

   706     cleanup();

   707 }

   708 

   709 void TestMPXVideoViewWrapper::testHandlePlaybackCommandComplete()

   710 {

   711     init();

   712 

   713     CMPXCommand* cmd = NULL;

   714 

   715     TRAP_IGNORE( cmd = CMPXCommand::NewL() );

   716 

   717     mVideoViewWrapper->HandlePlaybackCommandComplete( cmd, KErrNone );

   718 

   719     QVERIFY( mVideoViewWrapper );

   720 

   721     delete cmd;

   722     cmd = NULL;

   723 

   724     cleanup();

   725 }

   726 

   727 void TestMPXVideoViewWrapper::testHandleMedia()

   728 {

   729     init();

   730 

   731     CMPXMedia* media = NULL;

   732 

   733     //

   734     // Error case

   735     //

   736     TRAP_IGNORE(

   737         RArray<TInt> suppIds;

   738         CleanupClosePushL( suppIds );

   739         suppIds.AppendL( KMPXMediaIdGeneral );

   740         suppIds.AppendL( KMPXMediaIdVideo );

   741 

   742         media = CMPXMedia::NewL( suppIds.Array() );

   743         CleanupStack::PopAndDestroy( &suppIds );

   744 

   745         media->SetTObjectValueL<TInt>( TMPXAttribute( KMPXMediaVideoError ), KErrCancel );

   746     );

   747 

   748     TRAPD( err, mVideoViewWrapper->HandleMediaL( *media, KErrNone ) );

   749     QVERIFY( err == KErrNone );

   750 

   751     QCOMPARE( mVideoViewWrapper->iView->mCurrentError, KErrCancel );

   752     QVERIFY( ! mVideoViewWrapper->iControlsController->mFileDetailsAdded );

   753     QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaNotRequested );

   754 

   755     if ( media )

   756     {

   757         delete media;

   758         media = NULL;

   759     }

   760 

   761     //

   762     // working case - RN logo is not visible

   763     //

   764     TRAP_IGNORE(

   765         RArray<TInt> suppIds;

   766         CleanupClosePushL( suppIds );

   767         suppIds.AppendL( KMPXMediaIdGeneral );

   768         suppIds.AppendL( KMPXMediaIdVideo );

   769 

   770         media = CMPXMedia::NewL( suppIds.Array() );

   771         CleanupStack::PopAndDestroy( &suppIds );

   772     );

   773 

   774     mVideoViewWrapper->iView->mCurrentError = KErrNone;

   775     mVideoViewWrapper->iFileDetails->mVideoEnabled = true;

   776     mVideoViewWrapper->iDisplayHandler->SetAspectRatioL( EPbCmdNaturalAspectRatio );

   777     mVideoViewWrapper->iControlsController->mRNLogoVisible = false;

   778 

   779     TRAP(err, mVideoViewWrapper->HandleMediaL( *media, KErrNone ) );

   780 

   781     QVERIFY( err == KErrNone );

   782     QCOMPARE( mVideoViewWrapper->iView->mCurrentError, KErrNone );

   783     QVERIFY( mVideoViewWrapper->iControlsController->mFileDetailsAdded );

   784     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetAspectRatio );

   785     QVERIFY( mVideoViewWrapper->iControlsController->mValue == EMMFNatural );

   786     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

   787     QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaDelivered );

   788 

   789     if ( media )

   790     {

   791         delete media;

   792         media = NULL;

   793     }

   794 

   795     //

   796     // working case - RN logo is visible

   797     //

   798     TRAP_IGNORE(

   799         RArray<TInt> suppIds;

   800         CleanupClosePushL( suppIds );

   801         suppIds.AppendL( KMPXMediaIdGeneral );

   802         suppIds.AppendL( KMPXMediaIdVideo );

   803 

   804         media = CMPXMedia::NewL( suppIds.Array() );

   805         CleanupStack::PopAndDestroy( &suppIds );

   806     );

   807 

   808     mVideoViewWrapper->iFileDetails->mVideoEnabled = false;

   809     mVideoViewWrapper->iPlaybackUtility->iCommand = EPbCmdPause;

   810     mVideoViewWrapper->iControlsController->mFileDetailsAdded = false;

   811     mVideoViewWrapper->iDisplayHandler->SetAspectRatioL( EPbCmdZoomAspectRatio );

   812     mVideoViewWrapper->iControlsController->mRNLogoVisible = true;

   813 

   814     TRAP(err, mVideoViewWrapper->HandleMediaL( *media, KErrNone ) );

   815 

   816     QVERIFY( err == KErrNone );

   817     QVERIFY( ! mVideoViewWrapper->iControlsController->mFileDetailsAdded );

   818     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetAspectRatio );

   819     QVERIFY( mVideoViewWrapper->iControlsController->mValue == EMMFNatural );

   820     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPause );

   821     QCOMPARE( mVideoViewWrapper->iView->mCurrentError, KErrNone );

   822     QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaDelivered );

   823 

   824     if ( media )

   825     {

   826         delete media;

   827         media = NULL;

   828     }

   829 

   830     cleanup();

   831 }

   832 

   833 // End of file