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 <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 #include <vcxmyvideosuids.h>

    35 #include <mpxmediageneralextdefs.h>

    36 

    37 #include "mpxcollectionutility.h"

    38 #include "mpxcollectionplaylist.h"

    39 #include "testmpxvideoviewwrapper.h"

    40 

    41 #include "../stub/inc/videobaseplaybackview.h"

    42 #include "../stub/inc/videoplaybackviewfiledetails.h"

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

    44 #include "../stub/inc/videoplaybackcontrolscontroller.h"

    45 

    46 

    47 #define protected public

    48 #include "mpxvideoviewwrapper.h"

    49 #undef protected

    50 

    51 

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

    53 // main

    54 // ---------------------------------------------------------------------------

    55 //

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

    57 {

    58     HbApplication app(argc, argv);

    59     HbMainWindow window;

    60 

    61     TestMPXVideoViewWrapper tv;

    62 

    63     char *pass[3];

    64     pass[0] = argv[0];

    65     pass[1] = "-o";

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

    67 

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

    69 

    70     return res;

    71 }

    72 

    73 // ---------------------------------------------------------------------------

    74 // init

    75 // ---------------------------------------------------------------------------

    76 //

    77 void TestMPXVideoViewWrapper::init()

    78 {

    79     mBaseVideoView    = new VideoBasePlaybackView();

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

    81     QVERIFY( err == KErrNone );

    82 }

    83 

    84 // ---------------------------------------------------------------------------

    85 // cleanup

    86 // ---------------------------------------------------------------------------

    87 //

    88 void TestMPXVideoViewWrapper::cleanup()

    89 {

    90     if ( mVideoViewWrapper )

    91     {

    92         delete mVideoViewWrapper;

    93         mVideoViewWrapper = NULL;

    94     }

    95 

    96     if ( mBaseVideoView )

    97     {

    98         delete mBaseVideoView;

    99         mBaseVideoView = NULL;

   100     }

   101 }

   102 

   103 void TestMPXVideoViewWrapper::testRequestMedia()

   104 {

   105     init();

   106 

   107     //

   108     // If iMediaRequestStatus is not MediaNotRequested, doesn't request media

   109     //

   110     mVideoViewWrapper->iMediaRequestStatus = MediaDelivered;

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

   112     QVERIFY( err == KErrNone );

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

   114 

   115     //

   116     // If iState is not EPbStateInitialised, doesn't request media

   117     //

   118     mVideoViewWrapper->iMediaRequestStatus = MediaNotRequested;

   119     mVideoViewWrapper->iPlaybackUtility->iState = EPbStatePluginSeeking;

   120 

   121     TRAP(err, mVideoViewWrapper->RequestMediaL());

   122     QVERIFY( err == KErrNone );

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

   124 

   125     //

   126     // If it is not playlist case, request playback media

   127     //

   128     mVideoViewWrapper->iPlaylistView = false;

   129     mVideoViewWrapper->iMediaRequestStatus = MediaNotRequested;

   130     mVideoViewWrapper->iPlaybackUtility->iState = EPbStateInitialised;

   131 

   132     TRAP(err, mVideoViewWrapper->RequestMediaL());

   133     QVERIFY( err == KErrNone );

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

   135     QVERIFY( ! mVideoViewWrapper->iCollectionMediaRequested );

   136 

   137     //

   138     // If it is playlist case && there isn't in memory plugin, request playback media

   139     //

   140     mVideoViewWrapper->iPlaylistView = true;

   141     mVideoViewWrapper->iMediaRequestStatus = MediaNotRequested;

   142     mVideoViewWrapper->iPlaybackUtility->iState = EPbStateInitialised;

   143     mVideoViewWrapper->iCollectionUtility->Collection().iUid = TUid::Uid( KVcxUidMyVideosMpxCollection );

   144 

   145     TRAP(err, mVideoViewWrapper->RequestMediaL());

   146     QVERIFY( err == KErrNone );

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

   148     QVERIFY( ! mVideoViewWrapper->iCollectionMediaRequested );

   149 

   150     //

   151     // If it is playlist case && there is in memory plugin, request collection media

   152     //

   153     mVideoViewWrapper->iPlaylistView = true;

   154     mVideoViewWrapper->iMediaRequestStatus = MediaNotRequested;

   155     mVideoViewWrapper->iPlaybackUtility->iState = EPbStateInitialised;

   156     mVideoViewWrapper->iCollectionUtility->Collection().iUid = TUid::Uid( KMpxInMemoryPluginUid );

   157 

   158     TRAP(err, mVideoViewWrapper->RequestMediaL());

   159     QVERIFY( err == KErrNone );

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

   161     QVERIFY( mVideoViewWrapper->iCollectionMediaRequested );

   162 

   163     cleanup();

   164 }

   165 

   166 void TestMPXVideoViewWrapper::testIsLive()

   167 {

   168     init();

   169 

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

   171     QVERIFY( err == KErrNone );

   172 

   173     mVideoViewWrapper->iFileDetails->mPlaybackMode = EMPXVideoLiveStreaming;

   174     QVERIFY( mVideoViewWrapper->IsLive() );

   175 

   176     mVideoViewWrapper->iFileDetails->mPlaybackMode = EMPXVideoLocal;

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

   178 

   179     cleanup();

   180 }

   181 

   182 void TestMPXVideoViewWrapper::testIsPlaylist()

   183 {

   184     init();

   185 

   186     mVideoViewWrapper->iPlaylistView = true;

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

   188 

   189     mVideoViewWrapper->iPlaylistView = false;

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

   191 

   192     cleanup();

   193 }

   194 

   195 void TestMPXVideoViewWrapper::testHandleCommand()

   196 {

   197     init();

   198 

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

   200     QVERIFY( errReqMedia == KErrNone );

   201 

   202     //

   203     // Test 'Play' command

   204     //

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

   206     QVERIFY( errHdlCmd == KErrNone );

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

   208 

   209     //

   210     // Test 'Pause' command

   211     //

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

   213     QVERIFY( errHdlCmd == KErrNone );

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

   215 

   216     //

   217     // Test 'Close' command

   218     //

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

   220     QVERIFY( errHdlCmd == KErrNone );

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

   222 

   223     //

   224     // Test 'Seek Forward' command

   225     //

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

   227     QVERIFY( errHdlCmd == KErrNone );

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

   229 

   230     //

   231     // Test 'Seek Backward' command

   232     //

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

   234     QVERIFY( errHdlCmd == KErrNone );

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

   236 

   237     //

   238     // Test 'End Seek' command

   239     //

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

   241     QVERIFY( errHdlCmd == KErrNone );

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

   243 

   244     //

   245     // Test 'PlayPause' command

   246     //

   247     mVideoViewWrapper->iPlaybackState = EPbStatePlaying;

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

   249     QVERIFY( errHdlCmd == KErrNone );

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

   251 

   252     mVideoViewWrapper->iPlaybackState = EPbStatePaused;

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

   254     QVERIFY( errHdlCmd == KErrNone );

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

   256 

   257     //

   258     // Test 'Stop' command

   259     //

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

   261     QVERIFY( errHdlCmd == KErrNone );

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

   263 

   264     //

   265     // Test 'Decrease Volume' command

   266     //

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

   268     QVERIFY( errHdlCmd == KErrNone );

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

   270 

   271     //

   272     // Test 'Increase Volume' command

   273     //

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

   275     QVERIFY( errHdlCmd == KErrNone );

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

   277 

   278     //

   279     // Test 'Natural Aspect Ratio' command

   280     //

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

   282     QVERIFY( errHdlCmd == KErrNone );

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

   284 

   285     //

   286     // Test 'Zoom Aspect Ratio' command

   287     //

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

   289     QVERIFY( errHdlCmd == KErrNone );

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

   291 

   292     //

   293     // Test 'Stretch Aspect Ratio' command

   294     //

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

   296     QVERIFY( errHdlCmd == KErrNone );

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

   298 

   299     //

   300     // Test 'Mute' command

   301     //

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

   303     QVERIFY( errHdlCmd == KErrNone );

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

   305 

   306     //

   307     // Test 'Un-mute' command

   308     //

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

   310     QVERIFY( errHdlCmd == KErrNone );

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

   312 

   313     //

   314     // Test 'Short Press Backward' command

   315     //

   316     mVideoViewWrapper->iPlaylistView = false;

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

   318     QVERIFY( errHdlCmd == KErrNone );

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

   320 

   321     //

   322     // Test 'Reset Controls' command

   323     //

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

   325     QVERIFY( errHdlCmd == KErrNone );

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

   327 

   328     //

   329     // Test 'Next List Item' command

   330     //

   331     mVideoViewWrapper->iPlaylistView = true;

   332     mVideoViewWrapper->iFileDetails->mMultiItemPlaylist = true;

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

   334     QVERIFY( errHdlCmd == KErrNone );

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

   336 

   337     //

   338     // Test 'Previous List Item' command

   339     //

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

   341     QVERIFY( errHdlCmd == KErrNone );

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

   343 

   344     //

   345     // Test 'End Of Clip' command

   346     //

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

   348     QVERIFY( errHdlCmd == KErrNone );

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

   350 

   351     //

   352     // Test 'Custom Pause' command

   353     //

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

   355     QVERIFY( errHdlCmd == KErrNone );

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

   357 

   358     //

   359     // Test 'Custom Play' command

   360     //

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

   362     QVERIFY( errHdlCmd == KErrNone );

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

   364 

   365     //

   366     // Test 'RealOne Bitmap Timeout' command

   367     //

   368     mVideoViewWrapper->iMediaRequestStatus = MediaDelivered;

   369     mVideoViewWrapper->iView->mStayPaused = false;

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

   371     QVERIFY( errHdlCmd == KErrNone );

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

   373 

   374     cleanup();

   375 }

   376 

   377 void TestMPXVideoViewWrapper::testHandlePluginError()

   378 {

   379     init();

   380 

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

   382     QVERIFY( errReqMedia == KErrNone );

   383 

   384     mVideoViewWrapper->HandlePluginError( KErrNotSupported );

   385 

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

   387 

   388     cleanup();

   389 }

   390 

   391 void TestMPXVideoViewWrapper::testHandlePlaybackMessage()

   392 {

   393     init();

   394 

   395     //***************************

   396     // Test Video Msg

   397     //***************************

   398     CMPXMessage* message = NULL;

   399     TRAP_IGNORE(

   400         message = CMPXMessage::NewL();

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

   402         message->SetTObjectValueL<TMPXVideoPlaybackCommand>

   403                                             ( KMPXMediaVideoPlaybackCommand, EPbCmdTvOutEvent );

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

   405     );

   406     mVideoViewWrapper->HandlePlaybackMessage( message, KErrNone );

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

   408     if ( message )

   409     {

   410         delete message;

   411         message = NULL;

   412     }

   413 

   414     //***************************

   415     // Test General Msg

   416     //***************************

   417     TRAP_IGNORE(

   418         message = CMPXMessage::NewL();

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

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

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

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

   423     );

   424     mVideoViewWrapper->HandlePlaybackMessage( message, KErrNone );

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

   426     if ( message )

   427     {

   428         delete message;

   429         message = NULL;

   430     }

   431 

   432     //***************************

   433     // Test Video Msg with err

   434     //***************************

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

   436     mVideoViewWrapper->HandlePlaybackMessage( message, KErrNotFound );

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

   438     if ( message )

   439     {

   440         delete message;

   441         message = NULL;

   442     }

   443 

   444     cleanup();

   445 }

   446 

   447 void TestMPXVideoViewWrapper::testSetProperty()

   448 {

   449     init();

   450 

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

   452     QVERIFY( errReqMedia == KErrNone );

   453 

   454     TMPXPlaybackProperty property = EPbPropertyMute;

   455     TInt propertyValue = 1;

   456 

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

   458     QVERIFY( errSetProp == KErrNone );

   459 

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

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

   462 

   463     cleanup();

   464 }

   465 

   466 void TestMPXVideoViewWrapper::testHandleProperty()

   467 {

   468     init();

   469 

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

   471     QVERIFY( errReqMedia == KErrNone );

   472 

   473     //

   474     // Duration

   475     //

   476     int value = 5000;

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

   478     QVERIFY( errHdlProp == KErrNone );

   479 

   480     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetDuration );

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

   482 

   483     //

   484     // Position

   485     //

   486     value = 500;

   487 

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

   489     QVERIFY( errHdlProp == KErrNone );

   490 

   491     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetPosition );

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

   493 

   494     //

   495     // Volume

   496     //

   497     value = 10;

   498 

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

   500     QVERIFY( errHdlProp == KErrNone );

   501 

   502     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetVolume );

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

   504 

   505     //

   506     // Mute

   507     //

   508     value = 1;

   509 

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

   511     QVERIFY( errHdlProp == KErrNone );

   512 

   513     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetVolume );

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

   515 

   516     cleanup();

   517 }

   518 

   519 void TestMPXVideoViewWrapper::testRetrieveFileNameAndMode()

   520 {

   521     init();

   522 

   523     mVideoViewWrapper->iFileDetails->clearFileDetails();

   524 

   525     CMPXCommand* cmd = NULL;

   526 

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

   528 

   529     if ( cmd )

   530     {

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

   532         QVERIFY( errRetFileName == KErrNone );

   533 

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

   535 

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

   537 

   538         delete cmd;

   539         cmd = NULL;

   540     }

   541 

   542     cleanup();

   543 }

   544 

   545 void TestMPXVideoViewWrapper::testActivateClosePlayerActiveObject()

   546 {

   547     init();

   548 

   549     mVideoViewWrapper->ActivateClosePlayerActiveObject();

   550 

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

   552 

   553     cleanup();

   554 }

   555 

   556 void TestMPXVideoViewWrapper::testDoClosePlayer()

   557 {

   558     init();

   559 

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

   561     QVERIFY( err == KErrNone );

   562 

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

   564 

   565     cleanup();

   566 }

   567 

   568 void TestMPXVideoViewWrapper::testSetAspectRatio()

   569 {

   570     init();

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

   572     QVERIFY( errReqMedia == KErrNone );

   573 

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

   575     QVERIFY( errHdlCmd == KErrNone );

   576 

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

   578 

   579     cleanup();

   580 }

   581 

   582 void TestMPXVideoViewWrapper::testIsAppInFront()

   583 {

   584     init();

   585 

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

   587     QVERIFY( errReqMedia == KErrNone );

   588 

   589     bool front = false;

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

   591 

   592     QVERIFY( errIsAppInFrnt == KErrNone );

   593 

   594     cleanup();

   595 }

   596 

   597 void TestMPXVideoViewWrapper::testClosePlaybackView()

   598 {

   599     init();

   600 

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

   602     QVERIFY( err == KErrNone );

   603 

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

   605 

   606     cleanup();

   607 }

   608 

   609 void TestMPXVideoViewWrapper::testHandleVolumeCmd()

   610 {

   611     init();

   612 

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

   614     QVERIFY( errReqMedia == KErrNone );

   615 

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

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

   618     QVERIFY( errIssuePlay == KErrNone );

   619 

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

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

   622     QVERIFY( errHdlCmd == KErrNone );

   623 

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

   625 

   626     cleanup();

   627 }

   628 

   629 void TestMPXVideoViewWrapper::testHandleShortPressBackward()

   630 {

   631     init();

   632 

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

   634     QVERIFY( errReqMedia == KErrNone );

   635 

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

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

   638     QVERIFY( errIssuePlay == KErrNone );

   639 

   640     mVideoViewWrapper->iPlaylistView = false;

   641 

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

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

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

   645 

   646     QVERIFY( errHdlCmd == KErrNone );

   647 

   648     cleanup();

   649 }

   650 

   651 void TestMPXVideoViewWrapper::testIssueVideoAppForegroundCmd()

   652 {

   653     init();

   654 

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

   656     QVERIFY( errReqMedia == KErrNone );

   657 

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

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

   660 

   661     QVERIFY( errIssuePlay == KErrNone );

   662 

   663     //

   664     // test foreground

   665     //

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

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

   668     QVERIFY( errIssueVidAppFGCmd == KErrNone );

   669 

   670     //

   671     // test background

   672     //

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

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

   675     QVERIFY( errIssueVidAppFGCmd == KErrNone );

   676 

   677     cleanup();

   678 }

   679 

   680 void TestMPXVideoViewWrapper::testCreateControls()

   681 {

   682     init();

   683 

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

   685     QVERIFY( err == KErrNone );

   686 

   687     QVERIFY( mVideoViewWrapper->iControlsController );

   688 

   689     cleanup();

   690 }

   691 

   692 void TestMPXVideoViewWrapper::testIsMultiItemPlaylist()

   693 {

   694     init();

   695 

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

   697     QVERIFY( errReqMedia == KErrNone );

   698 

   699     mVideoViewWrapper->iFileDetails->mMultiItemPlaylist = false;

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

   701 

   702     mVideoViewWrapper->iFileDetails->mMultiItemPlaylist = true;

   703     QVERIFY( mVideoViewWrapper->IsMultiItemPlaylist() );

   704 

   705     cleanup();

   706 }

   707 

   708 void TestMPXVideoViewWrapper::testUpdateVideoRect()

   709 {

   710     init();

   711 

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

   713     QVERIFY( errReqMedia == KErrNone );

   714 

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

   716 

   717     mVideoViewWrapper->UpdateVideoRect(

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

   719 

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

   721 

   722     cleanup();

   723 }

   724 

   725 void TestMPXVideoViewWrapper::testUpdateVideoRectDone()

   726 {

   727     init();

   728 

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

   730     QVERIFY( errReqMedia == KErrNone );

   731 

   732     mVideoViewWrapper->UpdateVideoRectDone();

   733 

   734     cleanup();

   735 }

   736 

   737 void TestMPXVideoViewWrapper::testHandleBufferingState()

   738 {

   739     init();

   740 

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

   742     QVERIFY( err == KErrNone );

   743 

   744     cleanup();

   745 }

   746 

   747 void TestMPXVideoViewWrapper::testHandleVideoPlaybackMessage()

   748 {

   749     init();

   750 

   751     CMPXMessage* message = NULL;

   752     TRAP_IGNORE(

   753         message = CMPXMessage::NewL();

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

   755         message->SetTObjectValueL<TMPXVideoPlaybackCommand>

   756                                             ( KMPXMediaVideoPlaybackCommand, EPbCmdPluginError );

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

   758     );

   759 

   760     mVideoViewWrapper->HandleVideoPlaybackMessage( message );

   761 

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

   763     if ( message )

   764     {

   765         delete message;

   766         message = NULL;

   767     }

   768 

   769     cleanup();

   770 }

   771 

   772 void TestMPXVideoViewWrapper::testHandlePlaybackCommandComplete()

   773 {

   774     init();

   775 

   776     CMPXCommand* cmd = NULL;

   777 

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

   779 

   780     mVideoViewWrapper->HandlePlaybackCommandComplete( cmd, KErrNone );

   781 

   782     QVERIFY( mVideoViewWrapper );

   783 

   784     delete cmd;

   785     cmd = NULL;

   786 

   787     cleanup();

   788 }

   789 

   790 void TestMPXVideoViewWrapper::testHandleMedia()

   791 {

   792     init();

   793 

   794     CMPXMedia* media = NULL;

   795     mVideoViewWrapper->iCollectionMediaRequested = false;

   796 

   797     //

   798     // Handle playback media - Error case

   799     //

   800     TRAP_IGNORE(

   801         RArray<TInt> suppIds;

   802         CleanupClosePushL( suppIds );

   803         suppIds.AppendL( KMPXMediaIdGeneral );

   804         suppIds.AppendL( KMPXMediaIdVideo );

   805 

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

   807         CleanupStack::PopAndDestroy( &suppIds );

   808 

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

   810     );

   811 

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

   813     QVERIFY( err == KErrNone );

   814 

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

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

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

   818 

   819     if ( media )

   820     {

   821         delete media;

   822         media = NULL;

   823     }

   824 

   825     //

   826     //  Handle playback media - working case - RN logo is not visible

   827     //

   828     TRAP_IGNORE(

   829         RArray<TInt> suppIds;

   830         CleanupClosePushL( suppIds );

   831         suppIds.AppendL( KMPXMediaIdGeneral );

   832         suppIds.AppendL( KMPXMediaIdVideo );

   833 

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

   835         CleanupStack::PopAndDestroy( &suppIds );

   836     );

   837 

   838     mVideoViewWrapper->iView->mCurrentError = KErrNone;

   839     mVideoViewWrapper->iFileDetails->mVideoEnabled = true;

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

   841     mVideoViewWrapper->iControlsController->mRNLogoVisible = false;

   842     mVideoViewWrapper->iView->mStayPaused = false;

   843 

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

   845 

   846     QVERIFY( err == KErrNone );

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

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

   849     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetAspectRatio );

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

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

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

   853 

   854     if ( media )

   855     {

   856         delete media;

   857         media = NULL;

   858     }

   859 

   860     //

   861     // working case - re-play after previous termination 

   862     //

   863     TRAP_IGNORE(

   864         RArray<TInt> suppIds;

   865         CleanupClosePushL( suppIds );

   866         suppIds.AppendL( KMPXMediaIdGeneral );

   867         suppIds.AppendL( KMPXMediaIdVideo );

   868 

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

   870         CleanupStack::PopAndDestroy( &suppIds );

   871     );

   872 

   873     mVideoViewWrapper->iView->mCurrentError = KErrNone;

   874     mVideoViewWrapper->iFileDetails->mVideoEnabled = true;

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

   876     mVideoViewWrapper->iControlsController->mRNLogoVisible = false;

   877     mVideoViewWrapper->iView->mStayPaused = true;

   878 

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

   880 

   881     QVERIFY( err == KErrNone );

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

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

   884     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetAspectRatio );

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

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

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

   888 

   889     if ( media )

   890     {

   891         delete media;

   892         media = NULL;

   893     }    

   894     

   895     //

   896     //  Handle playback media - working case - RN logo is visible

   897     //

   898     TRAP_IGNORE(

   899         RArray<TInt> suppIds;

   900         CleanupClosePushL( suppIds );

   901         suppIds.AppendL( KMPXMediaIdGeneral );

   902         suppIds.AppendL( KMPXMediaIdVideo );

   903 

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

   905         CleanupStack::PopAndDestroy( &suppIds );

   906     );

   907 

   908     mVideoViewWrapper->iFileDetails->mVideoEnabled = false;

   909     mVideoViewWrapper->iPlaybackUtility->iCommand = EPbCmdPause;

   910     mVideoViewWrapper->iControlsController->mFileDetailsAdded = false;

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

   912     mVideoViewWrapper->iControlsController->mRNLogoVisible = true;

   913 

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

   915 

   916     QVERIFY( err == KErrNone );

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

   918     QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetAspectRatio );

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

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

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

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

   923 

   924     if ( media )

   925     {

   926         delete media;

   927         media = NULL;

   928     }

   929 

   930     //

   931     // Handle collection media

   932     //

   933     mVideoViewWrapper->iCollectionMediaRequested = true;

   934     bool seekable = true;

   935 

   936     TRAP_IGNORE(

   937         RArray<TInt> suppIds;

   938         CleanupClosePushL( suppIds );

   939         suppIds.AppendL( KMPXMediaIdGeneralExt );

   940 

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

   942         CleanupStack::PopAndDestroy( &suppIds );

   943 

   944         media->SetTObjectValueL<TInt>( TMPXAttribute( KMPXMediaGeneralExtVideoSeekable ), seekable );

   945     );

   946 

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

   948 

   949     QVERIFY( err == KErrNone );

   950     QVERIFY( ! mVideoViewWrapper->iCollectionMediaRequested );

   951     QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdUpdateSeekable );

   952 

   953     if ( media )

   954     {

   955         delete media;

   956         media = NULL;

   957     }

   958 

   959     cleanup();

   960 }

   961 

   962 // End of file