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:  

    15 *

    16 */

    17 

    18 

    19 #include "ut_lceffecthandler.h"

    20 #include "ut_lcuidefs.h"

    21 #include "lceffecthandler.h"

    22 #include "lcuiengine.h"

    23 #include "lcuidefs.h"

    24 #include "lcvideowidget.h"

    25 #include <QtTest/QtTest>

    26 #include <hbmainwindow.h>

    27 #include <hbinstance.h>

    28 

    29 #define UT_SET_ORIENTATION(orient) \

    30 HbInstance::instance()->allMainWindows().at(0)->setOrientation(orient);

    31 

    32 void UT_LcEffectHandler::initTestCase()

    33 {

    34     lcutStub_LcUiEngine_reset();

    35     //must have main window, even if it not used

    36     mMainWindow = new HbMainWindow();

    37 }

    38 

    39 void UT_LcEffectHandler::cleanupTestCase()

    40 {

    41     lcutStub_LcUiEngine_reset();

    42     delete mMainWindow;

    43 }

    44 

    45 

    46 void UT_LcEffectHandler::init()

    47 {

    48     mEngine = new LcUiEngine( lcEngineName, lcDisplayName );

    49 

    50     mSharedVideo = new LcVideoWidget();

    51     mSharedVideoOverlay = new LcVideoWidget(0,false);

    52     mReceivedVideo = new LcVideoWidget();

    53     mReceivedVideoOverlay = new LcVideoWidget(0,false);

    54     mEffectHandler = new LcEffectHandler(

    55             *mEngine,mSharedVideo,mSharedVideoOverlay,

    56             mReceivedVideo,mReceivedVideoOverlay);

    57     

    58 }

    59 

    60 void UT_LcEffectHandler::cleanup()

    61 {

    62     lcutStub_LcUiEngine_reset();

    63     delete mEffectHandler;

    64     delete mEngine;

    65     delete mSharedVideo;

    66     delete mSharedVideoOverlay;

    67     delete mReceivedVideoOverlay;

    68     delete mReceivedVideo;

    69 }

    70 

    71 void UT_LcEffectHandler::testConstructor()

    72 {

    73     QVERIFY( mEffectHandler );

    74 }

    75 

    76 void UT_LcEffectHandler::testSwap()

    77 {

    78     clearWidgets();

    79     QSignalSpy spy( mEffectHandler, SIGNAL(loadSwapLayout()) );

    80     QVERIFY( !mEffectHandler->mSharedVideo );

    81     QVERIFY( !mEffectHandler->mReceivedVideo );

    82     QVERIFY( !mEffectHandler->mSwapInProgress );

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

    84 

    85     mEffectHandler->swap();

    86     setWidgets();

    87 

    88     QVERIFY( mEffectHandler->mSwapInProgress );

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

    90 

    91     HbWidget* sharedVideoWidget = mEffectHandler->mSharedVideo;

    92     HbWidget* receivedVideoWidget = mEffectHandler->mReceivedVideo;

    93     HbWidget* sharedVideoWidget2 = mEffectHandler->mSharedVideoOverlay;

    94     HbWidget* receivedVideoWidget2 = mEffectHandler->mReceivedVideoOverlay;

    95     QRectF sharedOrig = mEffectHandler->mSharedVideo->geometry();

    96     QRectF recvOrig = mEffectHandler->mReceivedVideo->geometry();

    97     

    98     // Swapping not started because other widget missing

    99     mEffectHandler->mSwapSharedCompleted = true;

   100     mEffectHandler->mSwapReceivedCompleted = true;

   101     mEffectHandler->mSharedVideo = 0;

   102     mEffectHandler->swap();

   103     QCOMPARE( sharedVideoWidget->geometry(), sharedOrig );

   104     QCOMPARE( receivedVideoWidget->geometry(), recvOrig );

   105     QCOMPARE( mEffectHandler->mSwapSharedCompleted, true );

   106     QCOMPARE( mEffectHandler->mSwapReceivedCompleted, true );

   107     

   108     // Swapping not started because other widget missing

   109     mEffectHandler->mSharedVideo = sharedVideoWidget;

   110     mEffectHandler->mReceivedVideo = 0;

   111     mEffectHandler->swap();

   112     QCOMPARE( sharedVideoWidget->geometry(), sharedOrig );

   113     QCOMPARE( receivedVideoWidget->geometry(), recvOrig );

   114     QCOMPARE( mEffectHandler->mSwapSharedCompleted, true );

   115     QCOMPARE( mEffectHandler->mSwapReceivedCompleted, true );

   116     

   117     // Swapping started, however geometry is change only once swapping completes

   118     mEffectHandler->mSharedVideo = sharedVideoWidget;

   119     mEffectHandler->mReceivedVideo = receivedVideoWidget;

   120     mEffectHandler->swap();

   121     

   122     QCOMPARE( sharedVideoWidget->geometry(), sharedOrig );

   123     QCOMPARE( receivedVideoWidget->geometry(), recvOrig );

   124     QCOMPARE( mEffectHandler->mSwapSharedCompleted, false );

   125     QCOMPARE( mEffectHandler->mSwapReceivedCompleted, false );

   126     

   127     // Swapping started, however geometry is change only once swapping completes

   128     mEffectHandler->mSwapSharedCompleted = true;

   129     mEffectHandler->mSwapReceivedCompleted = true;

   130     mEffectHandler->swap();

   131     QCOMPARE( sharedVideoWidget->geometry(), sharedOrig );

   132     QCOMPARE( receivedVideoWidget->geometry(), recvOrig );

   133     QCOMPARE( mEffectHandler->mSwapSharedCompleted, false );

   134     QCOMPARE( mEffectHandler->mSwapReceivedCompleted, false );

   135 }

   136 

   137 void UT_LcEffectHandler::testShowSendWindow()

   138 {

   139     // Shared video widget does not exist

   140     setWidgets();

   141     HbWidget* sharedVideoWidget = mEffectHandler->mSharedVideo;

   142     QVERIFY( sharedVideoWidget != 0 );

   143     sharedVideoWidget->hide();

   144     QVERIFY( !sharedVideoWidget->isVisible() );

   145     mEffectHandler->mSharedVideo = 0;

   146     mEffectHandler->showSendWindow();

   147     QVERIFY( !sharedVideoWidget->isVisible() );

   148 

   149     // Shared video widget exists, effects running, dont show

   150     HbEffect::mRunning = true;

   151     mEffectHandler->mSharedVideo = sharedVideoWidget;

   152     mEffectHandler->showSendWindow();

   153     QVERIFY( !mEffectHandler->mSharedVideo->isVisible() );

   154 

   155     // Shared video widget exists, show

   156     HbEffect::mRunning = false;

   157     mEffectHandler->mSharedVideo = sharedVideoWidget;

   158     mEffectHandler->showSendWindow();

   159     QVERIFY( mEffectHandler->mSharedVideo->isVisible() );

   160 }

   161 

   162 void UT_LcEffectHandler::testHideSendWindow()

   163 {

   164  // Shared video widget does not exist

   165     setWidgets();

   166     HbWidget* sharedVideoWidget = mEffectHandler->mSharedVideo;

   167     QVERIFY( sharedVideoWidget != 0 );

   168     mEffectHandler->mSharedVideo = 0;

   169     mEffectHandler->hideSendWindow();

   170 

   171     // Shared video widget exists, show

   172     mEffectHandler->mSharedVideo = sharedVideoWidget;

   173     mEffectHandler->showSendWindow();

   174     QVERIFY( mEffectHandler->mSharedVideo->isVisible() );

   175     

   176     // Shared video widget exists, hide

   177     mEffectHandler->hideSendWindow();

   178     QVERIFY( !mEffectHandler->mSharedVideo->isVisible() );     

   179 }

   180 

   181 void UT_LcEffectHandler::testShowReceiveWindow()

   182 {

   183     // Shared video widget does not exist

   184     setWidgets();

   185     HbWidget* receivedVideoWidget = mEffectHandler->mReceivedVideo;

   186     QVERIFY( receivedVideoWidget != 0 );

   187     receivedVideoWidget->hide();

   188     QVERIFY( !receivedVideoWidget->isVisible() );

   189     mEffectHandler->mReceivedVideo = 0;

   190     mEffectHandler->showReceiveWindow();

   191     QVERIFY( !receivedVideoWidget->isVisible() );

   192     

   193     // Received video widget exists, show

   194     mEffectHandler->mReceivedVideo = receivedVideoWidget;

   195     mEffectHandler->showReceiveWindow();

   196     QVERIFY( mEffectHandler->mReceivedVideo->isVisible() );

   197 }

   198 

   199 void UT_LcEffectHandler::testHideReceiveWindow()

   200 {

   201     // Shared video widget does not exist

   202     setWidgets();

   203     HbWidget* receivedVideoWidget = mEffectHandler->mReceivedVideo;

   204     QVERIFY( receivedVideoWidget != 0 );

   205     mEffectHandler->mReceivedVideo = 0;

   206     mEffectHandler->hideReceiveWindow();

   207 

   208     

   209     // Received video widget exists, show

   210     mEffectHandler->mReceivedVideo = receivedVideoWidget;

   211     mEffectHandler->showReceiveWindow();

   212     QVERIFY( mEffectHandler->mReceivedVideo->isVisible() );

   213     

   214     // Receive video widget exists, hide

   215     mEffectHandler->hideReceiveWindow();

   216     QVERIFY( !mEffectHandler->mReceivedVideo->isVisible() );    

   217 }

   218 

   219 

   220 // windowFlipComplete

   221 // windowDisappearToFlipComplete

   222 // windowDisappearComplete

   223 // windowAppearComplete

   224 // WindowSwapSharedComplete

   225 // WindowSwapReceivedComplete

   226 

   227 void UT_LcEffectHandler::testEffectComplete()

   228 {

   229     clearWidgets();

   230     

   231     // Video widgets does not exist

   232     HbEffect::EffectStatus status;

   233     mEffectHandler->windowAppearComplete( status );

   234     mEffectHandler->windowDisappearComplete( status );

   235     mEffectHandler->windowDisappearToFlipComplete( status );

   236     mEffectHandler->windowFlipComplete( status );

   237 

   238     setWidgets();

   239 

   240     HbWidget* sharedVideoWidget = mEffectHandler->mSharedVideo;

   241     HbWidget* receivedVideoWidget = mEffectHandler->mReceivedVideo;

   242     sharedVideoWidget->hide();

   243     receivedVideoWidget->hide();

   244 

   245     mEffectHandler->showSendWindow();

   246     mEffectHandler->windowAppearComplete( status );

   247     QVERIFY( sharedVideoWidget->isVisible() );

   248 

   249     mEffectHandler->windowDisappearComplete( status );

   250     QVERIFY( sharedVideoWidget->isVisible() );

   251 

   252     mEffectHandler->windowDisappearToFlipComplete( status );

   253     QVERIFY( !sharedVideoWidget->isVisible() );

   254 

   255         lcutStub_LcUiEngine_setLocalPlaying( false );

   256     mEffectHandler->windowFlipComplete( status );

   257     QVERIFY( !sharedVideoWidget->isVisible() );

   258 

   259         lcutStub_LcUiEngine_setLocalPlaying( true );

   260     mEffectHandler->windowFlipComplete( status );

   261     QVERIFY( sharedVideoWidget->isVisible() );

   262 

   263     sharedVideoWidget->hide();

   264     receivedVideoWidget->hide();

   265         lcutStub_LcUiEngine_setLocalPlaying( true );

   266     mEffectHandler->windowFlipComplete( status );

   267     QVERIFY( sharedVideoWidget->isVisible() );

   268 

   269     // Swapping, real video widgets are set visible only after

   270     // both swap effects have completeded swapping completes and completion

   271     // is also signal

   272 

   273     // Geomerty changes are handled by the view using DoCML's

   274     // when swapping completes and completion is also signal

   275 

   276     QRectF pos1 = QRectF(5,100, 200, 200);

   277     QRectF pos2 = QRectF(5,300, 400, 400);

   278     mEffectHandler->mSharedVideo->setGeometry(pos1);

   279     mEffectHandler->mReceivedVideo->setGeometry(pos2);

   280     QSignalSpy spy( mEffectHandler, SIGNAL(swapCompleted()) );

   281     sharedVideoWidget->hide();

   282     receivedVideoWidget->hide();

   283         lcutStub_LcUiEngine_setLocalPlaying( true );

   284     mEffectHandler->windowSwapSharedComplete( status );

   285     QVERIFY( !sharedVideoWidget->isVisible() );

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

   287 

   288     sharedVideoWidget->hide();

   289     receivedVideoWidget->hide();

   290         lcutStub_LcUiEngine_setRemotePlaying( true );

   291     mEffectHandler->windowSwapReceivedComplete( status );

   292     QVERIFY( receivedVideoWidget->isVisible() );

   293     QVERIFY( sharedVideoWidget->isVisible() );

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

   295 

   296     // Players are disabled so even when swap completes, widgets are not set

   297     // visible

   298     sharedVideoWidget->hide();

   299     receivedVideoWidget->hide();

   300         lcutStub_LcUiEngine_setLocalPlaying( false );

   301     mEffectHandler->windowSwapSharedComplete( status );

   302     QVERIFY( !sharedVideoWidget->isVisible() );

   303     

   304     sharedVideoWidget->hide();

   305     receivedVideoWidget->hide();

   306         lcutStub_LcUiEngine_setRemotePlaying( false );

   307     mEffectHandler->windowSwapReceivedComplete( status );

   308     QVERIFY( !receivedVideoWidget->isVisible() );

   309     QVERIFY( !sharedVideoWidget->isVisible() );

   310 }

   311 

   312 void UT_LcEffectHandler::testStartEffect()

   313 {

   314     clearWidgets();

   315     

   316     const char *effectId = "myeffect";

   317     const char *callBack = "mycallback";

   318     

   319     QVERIFY( !mEffectHandler->mSharedVideo );

   320     QVERIFY( !mEffectHandler->mSharedVideoOverlay );

   321     mEffectHandler->startEffect( mEffectHandler->mSharedVideoOverlay,effectId, callBack);

   322     

   323     setWidgets();

   324     

   325     QVERIFY( mEffectHandler->mSharedVideo );

   326     QVERIFY( mEffectHandler->mSharedVideoOverlay );

   327     

   328     HbWidget* sharedVideoWidget = mEffectHandler->mSharedVideo;

   329     HbWidget* sharedVideoWidget2 = mEffectHandler->mSharedVideoOverlay;

   330     QRectF sharedOrig = mEffectHandler->mSharedVideo->geometry();

   331     

   332     mEffectHandler->mSharedVideo = 0;

   333     mEffectHandler->startEffect( mEffectHandler->mSharedVideoOverlay,effectId, callBack);

   334     

   335     mEffectHandler->mSharedVideo = sharedVideoWidget;

   336     mEffectHandler->mSharedVideoOverlay = 0;

   337     mEffectHandler->startEffect( mEffectHandler->mSharedVideoOverlay,effectId, callBack);

   338     

   339     mEffectHandler->mSharedVideo = sharedVideoWidget;

   340     mEffectHandler->mSharedVideoOverlay = sharedVideoWidget2;

   341     mEffectHandler->startEffect( mEffectHandler->mSharedVideoOverlay,effectId, callBack);

   342     

   343     QCOMPARE( sharedVideoWidget->geometry(), sharedVideoWidget2->geometry() );

   344 }

   345 

   346 void UT_LcEffectHandler::testSetVisibility()

   347 {

   348     setWidgets();

   349 

   350     QVERIFY( mEffectHandler->mSharedVideo );

   351     HbWidget* sharedVideoWidget = mEffectHandler->mSharedVideo;

   352     sharedVideoWidget->setVisible(false);

   353 

   354     //If Effects are not running than we can set the visibility of widget

   355     mEffectHandler->setVisibility(sharedVideoWidget,true);

   356     // TODO: setvisibility temporarily NOP

   357     /*QVERIFY( mEffectHandler->mSharedVideo->isVisible() );

   358 

   359     //If Effects are running we can not set the visibility of widget.

   360     HbEffect::mRunning = true;

   361     mEffectHandler->setVisibility(sharedVideoWidget,false);

   362     QVERIFY( mEffectHandler->mSharedVideo->isVisible() );*/

   363 }

   364 

   365 void UT_LcEffectHandler::testSetDissappearEffect()

   366 {

   367     QCOMPARE( mEffectHandler->mEffectCallBack,

   368         QString::fromAscii(lcEffectWinDefaultCallback ));

   369     mEffectHandler->setDissappearEffect(LcEffectHandler::DissappearToFlip );

   370     QCOMPARE( mEffectHandler->mEffectCallBack,

   371         QString::fromAscii("windowDisappearToFlipComplete" ));

   372     mEffectHandler->setDissappearEffect(LcEffectHandler::NormalDissappear );

   373     QCOMPARE( mEffectHandler->mEffectCallBack,

   374         QString::fromAscii("windowDisappearComplete" ));

   375 }

   376 

   377 void UT_LcEffectHandler::testIsSharedVideoAtTop()

   378 {

   379     setWidgets();

   380 

   381     QRectF pos1 = QRectF(5,100, 200, 200);

   382     QRectF pos2 = QRectF(5,300, 400, 400);

   383     mEffectHandler->mSharedVideo->setGeometry(pos1);

   384     mEffectHandler->mReceivedVideo->setGeometry(pos2);

   385 

   386     QVERIFY( mEffectHandler->isSharedVideoAtTop() );

   387 

   388     mEffectHandler->mSharedVideo->setGeometry(pos2);

   389     mEffectHandler->mReceivedVideo->setGeometry(pos1);

   390     QVERIFY( !mEffectHandler->isSharedVideoAtTop() );

   391 

   392 }

   393 

   394 void UT_LcEffectHandler::testVideosSideBySide()

   395 {

   396     setWidgets();

   397     QRectF pos1 = QRectF(5,100, 200, 200);

   398     QRectF pos2 = QRectF(5,300, 400, 400);

   399     QRectF pos3 = QRectF(5,100, 400, 400);

   400 

   401     mEffectHandler->mSharedVideo->setGeometry(pos1);

   402     mEffectHandler->mReceivedVideo->setGeometry(pos2);

   403 

   404     QVERIFY( !mEffectHandler->videosSideBySide() );

   405     mEffectHandler->mReceivedVideo->setGeometry(pos3);

   406     QVERIFY( mEffectHandler->videosSideBySide() );

   407 }

   408 

   409 void UT_LcEffectHandler::testHandleSwapCompletion()

   410 {

   411     QSignalSpy spy( mEffectHandler, SIGNAL(swapCompleted()) );

   412     mEffectHandler->mSwapInProgress = true;

   413     mEffectHandler->mSwapSharedCompleted = false;

   414     mEffectHandler->mSwapReceivedCompleted = false;

   415 

   416     // Test1: Swap is not completed.

   417     mEffectHandler->handleSwapCompletion();

   418     QVERIFY( mEffectHandler->mSwapInProgress );

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

   420 

   421     // Test2: Swap is partially completed.

   422     mEffectHandler->mSwapSharedCompleted = true;

   423     mEffectHandler->handleSwapCompletion();

   424     QVERIFY( mEffectHandler->mSwapInProgress );

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

   426 

   427     // Test 3. Swap Completed completely.

   428     mEffectHandler->mSwapSharedCompleted = true;

   429     mEffectHandler->mSwapReceivedCompleted = true;

   430     mEffectHandler->handleSwapCompletion();

   431     QVERIFY( !mEffectHandler->mSwapInProgress );

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

   433 

   434     //Test 4. Local & Remote are player are availble.

   435     lcutStub_LcUiEngine_setLocalPlaying( true );

   436     lcutStub_LcUiEngine_setRemotePlaying( true );

   437 

   438     mEffectHandler->handleSwapCompletion();

   439     QVERIFY( mEffectHandler->mSharedVideo->isVisible() );

   440     QVERIFY( mEffectHandler->mReceivedVideo->isVisible() );

   441 }

   442 

   443 void UT_LcEffectHandler::testIsSwapInProgress()

   444 {

   445     QVERIFY( !mEffectHandler->isSwapInProgress() );

   446     mEffectHandler->swap();

   447     QVERIFY( mEffectHandler->isSwapInProgress() );

   448 }

   449 

   450 

   451 // Helper Utility Function for the Unit Test.

   452 void UT_LcEffectHandler::clearWidgets()

   453 {

   454     mEffectHandler->mReceivedVideo = 0;

   455     mEffectHandler->mReceivedVideoOverlay = 0;

   456     mEffectHandler->mSharedVideo = 0;

   457     mEffectHandler->mSharedVideoOverlay = 0;

   458 }

   459 

   460 void UT_LcEffectHandler::setWidgets()

   461 {

   462     mEffectHandler->mReceivedVideo = mReceivedVideo;

   463     mEffectHandler->mReceivedVideoOverlay = mReceivedVideoOverlay;

   464     mEffectHandler->mSharedVideo = mSharedVideo;

   465     mEffectHandler->mSharedVideoOverlay = mSharedVideoOverlay;

   466 }

   467 

   468 

   469