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_lcview.h"

    20 #include "ut_lcuidefs.h"

    21 #include "lcview.h"

    22 #include "lcuiengine.h"         

    23 #include "lcuicomponentrepository.h"

    24 #include "lcuidefs.h"

    25 #include "lcvideowidget.h"

    26 #include "lceffecthandler.h"

    27 #include <QtTest/QtTest>

    28 #include <hbmainwindow.h>

    29 #include <hblabel.h>

    30 #include <hbmessagebox.h>

    31 #include <hbaction.h>

    32 #include <hbtoolbar.h>

    33 #include <hbmenu.h>

    34 #include <hbinstance.h>

    35 #include <hblineedit.h>

    36 #include <hbpushbutton.h>

    37 #include <hbzoomsliderpopup.h>

    38 #include <hbtransparentwindow.h>

    39 #include <qgraphicssceneevent.h>

    40 #include <qgraphicsitem.h>

    41 #include <QGesture.h>

    42 #include <dialpad.h>

    43 #include <HbTapGesture.h>

    44 

    45 // Stub Helper

    46 #include <hbstub_helper.h>

    47 

    48 #define UT_SET_ORIENTATION(orient) \

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

    50 

    51 void UT_LcView::initTestCase()

    52 {

    53     lcutStub_LcUiEngine_reset();

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

    55     mMainWindow = new HbMainWindow();

    56 }

    57 

    58 void UT_LcView::cleanupTestCase()

    59 {

    60     lcutStub_LcUiEngine_reset();

    61     delete mMainWindow;

    62 }

    63 

    64 

    65 void UT_LcView::init()

    66 {

    67     lcutStub_LcUiEngine_reset();

    68     mRecipient = new HbLabel();

    69     mEndCallButton = new HbPushButton();

    70     mEngine = new LcUiEngine( lcEngineName, lcDisplayName );

    71     mRepository = new LcUiComponentRepository( *mEngine );

    72     mView = new LcView( *mEngine, *mRepository );

    73     mView->mRecipient = mRecipient;

    74     mView->mEndCallButton = mEndCallButton;

    75     mAction = new HbAction();

    76     mAction2 = new HbAction();

    77 }

    78 

    79 void UT_LcView::cleanup()

    80 {

    81     lcutStub_LcUiEngine_reset();

    82     delete mRecipient;

    83     delete mView;

    84     delete mEngine;

    85     delete mRepository;

    86     delete mAction;

    87     delete mAction2;

    88     delete mEndCallButton;

    89 }

    90 

    91 void UT_LcView::testConstructor()

    92 {

    93     QVERIFY( mView );

    94 }

    95 

    96 void UT_LcView::testActivated()

    97 {

    98     lcutStub_LcUiEngine_reset();

    99     QVERIFY( lcutStub_LcUiEngine_getCurrentView() == 0 );

   100     mView->activated();

   101     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_updateSession, 0 ) );

   102     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setOrientation, 1 ) );

   103     QVERIFY( lcutStub_LcUiEngine_getCurrentView() == mView );

   104     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas, 2 ) );

   105     

   106     lcutStub_LcUiEngine_reset();

   107     mView->mChangeCameraAction = mAction;

   108     mView->mMuteAction = mAction;

   109     mView->mSpeakerAction = mAction;

   110 

   111     mView->activated();

   112     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_updateSession, 0 ) );

   113     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setOrientation, 1 ) );

   114     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas, 2 ) );

   115     

   116     lcutStub_LcUiEngine_reset();

   117     lcutStub_LcUiEngine_setCameraMain( true);

   118     lcutStub_LcUiEngine_setMuted( true);

   119     lcutStub_LcUiEngine_setSpeaker( true );

   120     

   121     mView->activated();

   122     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_updateSession, 0 ) );

   123     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setOrientation, 1 ) );

   124     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas, 2 ) );

   125 }

   126 

   127 void UT_LcView::testInit()

   128 {

   129     mRepository->mReturnSendVideo = false;

   130     mView->init();

   131     QVERIFY( mView->mRecipient );

   132     QVERIFY( !mView->mSharedVideoWidget );

   133     QVERIFY( !mView->mZoomSlider );

   134     

   135     mRepository->mReturnSendVideo = true;

   136     mView->init();

   137     QVERIFY( mView->mRecipient );

   138     QVERIFY( mView->mSharedVideoWidget );

   139     QVERIFY( mView->mZoomSlider );

   140     QVERIFY( mView->menu());

   141 }

   142 

   143 void UT_LcView::testDeactivated()

   144 {

   145     mView->deactivated();

   146     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas ) );

   147 }

   148 

   149 void UT_LcView::testSetCameraActionToMain()

   150 {

   151     mView->mChangeCameraAction = mAction;

   152     mView->mMuteAction = mAction;

   153     mView->mSpeakerAction = mAction;

   154     mView->mDisableCameraAction = mAction;

   155 

   156     mView->setCameraActionToMain();

   157     QVERIFY( mView->mChangeCameraAction->text().isEmpty() );

   158     QCOMPARE( mView->mChangeCameraAction->icon(), HbIcon(lcIconNameMainCamera) );

   159 }

   160 

   161 void UT_LcView::testSetCameraActionToSecondary()

   162 {

   163     mView->mChangeCameraAction = mAction;

   164     mView->mMuteAction = mAction;

   165     mView->mSpeakerAction = mAction;

   166     mView->mDisableCameraAction = mAction;

   167 

   168     mView->setCameraActionToSecondary();

   169     QVERIFY( mView->mChangeCameraAction->text().isEmpty() );

   170     QCOMPARE( mView->mChangeCameraAction->icon(), HbIcon(lcIconNameSecondaryCamera) );

   171 }

   172 

   173 void UT_LcView::testSetMuteActionToUnmute()

   174 {

   175     mView->mChangeCameraAction = mAction;

   176     mView->mMuteAction = mAction;

   177     mView->mSpeakerAction = mAction;

   178     mView->mDisableCameraAction = mAction;

   179     

   180     mView->setMuteActionToUnmute();

   181     QVERIFY( mView->mMuteAction->text().isEmpty() );

   182     QCOMPARE (mView->mMuteAction->icon(), HbIcon(lcIconNameUnmuteMic));

   183 }

   184 

   185 void UT_LcView::testSetMuteActionToMute()

   186 {

   187     mView->mChangeCameraAction = mAction;

   188     mView->mMuteAction = mAction;

   189     mView->mSpeakerAction = mAction;

   190     mView->mDisableCameraAction = mAction;

   191     

   192     mView->setMuteActionToMute();

   193     QVERIFY( mView->mMuteAction->text().isEmpty() );

   194     QCOMPARE (mView->mMuteAction->icon(), HbIcon(lcIconNameMuteMic));

   195 }

   196 

   197 void UT_LcView::testSetSpeakerActionToHandset()

   198 {

   199     mView->mChangeCameraAction = mAction;

   200     mView->mMuteAction = mAction;

   201     mView->mSpeakerAction = mAction;

   202     mView->mDisableCameraAction = mAction;

   203 

   204     mView->setSpeakerActionToHandset();

   205     QVERIFY( mView->mSpeakerAction->text().isEmpty() );

   206     QCOMPARE( mView->mSpeakerAction->icon(), HbIcon(lcIconNameHandset) );

   207 }

   208 

   209 void UT_LcView::testSetSpeakerActionToSpeaker()

   210 {

   211     mView->mChangeCameraAction = mAction;

   212     mView->mMuteAction = mAction;

   213     mView->mSpeakerAction = mAction;

   214     mView->mDisableCameraAction = mAction;

   215 

   216     mView->setSpeakerActionToSpeaker();

   217     QVERIFY( mView->mSpeakerAction->text().isEmpty() );

   218     QCOMPARE( mView->mSpeakerAction->icon(), HbIcon(lcIconNameLoudspeaker) );

   219 }

   220 

   221 void UT_LcView::testSetCameraActionToEnable()

   222 {

   223     mView->setCameraActionToEnable();

   224 

   225     mView->mDisableCameraAction = mAction;

   226     mView->mDisableCameraMenuAction = mAction2;

   227 

   228     mView->setCameraActionToEnable();

   229     QVERIFY( mView->mDisableCameraAction->text().isEmpty() );

   230     QCOMPARE( mView->mDisableCameraAction->icon(), HbIcon(lcIconNameEnableCamera) );

   231     QCOMPARE( mView->mDisableCameraMenuAction->text(), hbTrId( "txt_vt_menu_enable_camera" ) );   

   232 }

   233 

   234 void UT_LcView::testSetCameraActionToDisable()

   235 {

   236     mView->setCameraActionToDisable();

   237 

   238     mView->mDisableCameraAction = mAction;

   239     mView->mDisableCameraMenuAction = mAction2;

   240 

   241     mView->setCameraActionToDisable();

   242     QVERIFY( mView->mDisableCameraAction->text().isEmpty() );

   243     QCOMPARE( mView->mDisableCameraAction->icon(), HbIcon(lcIconNameDisableCamera) );

   244     QCOMPARE( mView->mDisableCameraMenuAction->text(), hbTrId( "txt_vt_menu_disable_camera" ) );   

   245 }

   246 

   247 

   248 void UT_LcView::testDisableControls()

   249 {

   250     mView->disableControls();

   251     QVERIFY( !mView->menu()->isEnabled() );

   252     QVERIFY( !mView->toolBar()->isEnabled() );

   253 }

   254 

   255 void UT_LcView::testEnableControls()

   256 {

   257     mView->menu()->setEnabled( false );

   258     mView->toolBar()->setEnabled( false );

   259     

   260     mView->enableControls();

   261     QVERIFY( mView->menu()->isEnabled() );

   262     QVERIFY( mView->toolBar()->isEnabled() );

   263 }

   264 

   265 

   266 void UT_LcView::testEndVideoSession()

   267 {

   268     mView->endVideoSession();

   269     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_stop ) );   

   270 }

   271 

   272 void UT_LcView::testMute()

   273 {

   274     QVERIFY( !mView->mLandscapeTimer );

   275     mView->mLandscapeTimer = new QTimer();

   276     mView->mLandscapeTimer->start();

   277     int oldTimerId = mView->mLandscapeTimer->timerId();

   278     mView->mute();

   279     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_mute ) );

   280     QVERIFY( mView->mLandscapeTimer->isActive() );

   281     QVERIFY( oldTimerId != mView->mLandscapeTimer->timerId() );

   282 }

   283 

   284 void UT_LcView::testChangeCamera()

   285 {

   286     mView->init();

   287     QVERIFY( mView->mLandscapeTimer );

   288     QVERIFY( mView->mLandscapeTimer->isActive() );

   289     int oldTimerId = mView->mLandscapeTimer->timerId();

   290     mView->changeCamera();

   291     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_toggleCamera ) );

   292     QVERIFY( mView->mLandscapeTimer->isActive() );

   293     QVERIFY( oldTimerId != mView->mLandscapeTimer->timerId() );

   294 }

   295 

   296 void UT_LcView::testSwitchToVoiceCall()

   297 {

   298     mView->switchToVoiceCall();

   299     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_stop ) );

   300 }

   301 

   302 void UT_LcView::testDisableCamera()

   303 {

   304     mView->init();

   305     QVERIFY( mView->mLandscapeTimer );

   306     QVERIFY( mView->mLandscapeTimer->isActive() );

   307     int oldTimerId = mView->mLandscapeTimer->timerId();

   308     mView->disableCamera();

   309     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_disableCamera ) );

   310     QVERIFY( mView->mLandscapeTimer->isActive() );

   311     QVERIFY( oldTimerId != mView->mLandscapeTimer->timerId() );

   312 }

   313 

   314 void UT_LcView::testSpeaker()

   315 {

   316     QVERIFY( !mView->mLandscapeTimer );

   317     mView->mLandscapeTimer = new QTimer();

   318     mView->mLandscapeTimer->start();

   319     int oldTimerId = mView->mLandscapeTimer->timerId();

   320     mView->speaker();

   321     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_speaker ) );

   322     QVERIFY( mView->mLandscapeTimer->isActive() );

   323     QVERIFY( oldTimerId != mView->mLandscapeTimer->timerId() );

   324 }

   325 

   326 void UT_LcView::testSwap()

   327 {

   328     QVERIFY( !mView->mSharedVideoWidget );

   329     QVERIFY( !mView->mReceivedVideoWidget );

   330     mView->swap();

   331     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutNoCall ) );

   332     

   333     lcutStub_LcUiEngine_reset();

   334     mView->init();

   335     mView->swap();

   336     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutNoCall ) );

   337 }

   338 

   339 void UT_LcView::testShowZoom()

   340 {

   341     QVERIFY( !mView->mSharedVideoWidget );

   342     QVERIFY( !mView->mZoomSlider );

   343     mView->showZoom();

   344     QVERIFY( !mView->mZoomSlider );

   345     QVERIFY( !mView->mSharedVideoWidget );

   346 

   347     LcVideoWidget sendVideo;

   348     mView->mSharedVideoWidget = &sendVideo;

   349     HbZoomSliderPopup zoomSlider;

   350     mView->mZoomSlider = &zoomSlider;

   351     

   352     QVERIFY( mView->mSharedVideoWidget );

   353     QVERIFY( mView->mZoomSlider );

   354     mView->showZoom();

   355     QVERIFY( mView->mSharedVideoWidget );

   356     QVERIFY( mView->mZoomSlider );

   357     QVERIFY( mView->mZoomSlider->isVisible() );

   358     LcControlValues values;

   359     mEngine->zoomValues( values );

   360     QCOMPARE( mView->mZoomSlider->value(), values.mValue );

   361     QCOMPARE( mView->mZoomSlider->minimum(), values.mMinValue );

   362     QCOMPARE( mView->mZoomSlider->maximum(), values.mMaxValue );

   363     

   364 }

   365 

   366 

   367 void UT_LcView::testNotSupported()

   368 {

   369     HbMainWindow mainWin;

   370     QVERIFY( mView->mNotSupportedNote );

   371     QVERIFY( !mView->mNotSupportedNote->isVisible() );

   372     mView->notSupported();

   373     QVERIFY( mView->mNotSupportedNote->isVisible() );

   374 }

   375 

   376 void UT_LcView::testUpdateVideoRects()

   377 {

   378     mView->init();

   379     LcVideoWidget* sharedVideoWidget = mView->mSharedVideoWidget;

   380     LcVideoWidget* receivedVideoWidget = mView->mReceivedVideoWidget;

   381 

   382     mView->mSharedVideoWidget = 0;

   383     mView->mReceivedVideoWidget = 0;

   384     mView->updateVideoRects();

   385     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_updateSession, 0 ) );

   386     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setOrientation, 1 ) );

   387     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas, 2 ) );

   388 

   389     mView->mSharedVideoWidget = sharedVideoWidget;

   390     mView->mReceivedVideoWidget = 0;

   391     mView->updateVideoRects();

   392     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_updateSession, 0 ) );

   393     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setOrientation, 1 ) );

   394     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas, 2 ) );

   395 

   396     mView->mSharedVideoWidget = 0;

   397     mView->mReceivedVideoWidget = receivedVideoWidget;

   398     mView->updateVideoRects();

   399     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_updateSession, 0 ) );

   400     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setOrientation, 1 ) );

   401     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas, 2 ) );

   402 

   403     mView->mSharedVideoWidget = sharedVideoWidget;

   404     mView->mReceivedVideoWidget = receivedVideoWidget;

   405     sharedVideoWidget->hide();

   406     receivedVideoWidget->hide();

   407 		lcutStub_LcUiEngine_setLocalPlaying( false );

   408 		lcutStub_LcUiEngine_setRemotePlaying( false );

   409     mView->updateVideoRects();

   410     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_updateSession, 0 ) );

   411     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setOrientation, 1 ) );

   412     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas, 2 ) );

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

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

   415 

   416     sharedVideoWidget->hide();

   417     receivedVideoWidget->hide();

   418 		lcutStub_LcUiEngine_setLocalPlaying( true );

   419 		lcutStub_LcUiEngine_setRemotePlaying( true );

   420     mView->updateVideoRects();

   421     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_updateSession, 0 ) );

   422     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setOrientation, 1 ) );

   423     QVERIFY( lcutStub_LcUiEngine_expectCall( lcutStub_LcUiEngine_setContentAreas, 2 ) );

   424     // TODO: effecthandler->setvisibility temporarily NOP

   425     /*QVERIFY( sharedVideoWidget->isVisible() );

   426     QVERIFY( receivedVideoWidget->isVisible() );*/

   427 }

   428 

   429 void UT_LcView::testCurrentLayout()

   430 {

   431     mView->init();

   432     QString layout;

   433     

   434     //1. Portrait layout

   435     UT_SET_ORIENTATION( Qt::Vertical );

   436     layout = mView->currentLayout();

   437     QVERIFY( layout == lcLayoutPortraitDefaultId );

   438 

   439     //2. Landscape layout

   440     UT_SET_ORIENTATION( Qt::Horizontal );

   441     layout = mView->currentLayout();

   442     QVERIFY( layout == lcLayoutLandscapeDefaultId );    

   443 

   444     //3. Landscape Swaped lcLayoutPortraitSwappedId

   445     

   446     // Shared window x cordintate is higher 

   447     // than Received windows x Cordinate.

   448     

   449     QRectF pos1 = QRectF(100,300, 400, 400);

   450     QRectF pos2 = QRectF(5,100, 200, 200);

   451 

   452     UT_SET_ORIENTATION( Qt::Horizontal );

   453     mView->mEffectHandler->mSwapInProgress = true;

   454     mView->mSharedVideoWidget->setGeometry(pos1);

   455     mView->mReceivedVideoWidget->setGeometry(pos2);

   456 

   457     layout = mView->currentLayout();

   458     QVERIFY( layout == lcLayoutLandscapeSwappedId );

   459 

   460     //4. If Its already Swaped Change to the normal Landscape Mode

   461     mView->mSharedVideoWidget->setGeometry(pos2);

   462     mView->mReceivedVideoWidget->setGeometry(pos1);

   463     layout = mView->currentLayout();

   464     QVERIFY( layout == lcLayoutLandscapeDefaultId );

   465 

   466 

   467     //5. Portrait Swaped lcLayoutPortraitSwappedId

   468 

   469     // Shared window y cordintate is higher 

   470     // than Received windows y Cordinate.

   471 

   472     UT_SET_ORIENTATION( Qt::Vertical );

   473     mView->mEffectHandler->mSwapInProgress = true;

   474     mView->mSharedVideoWidget->setGeometry(pos1);

   475     mView->mReceivedVideoWidget->setGeometry(pos2);

   476 

   477     layout = mView->currentLayout();

   478     QVERIFY( layout == lcLayoutPortraitSwappedId );

   479 

   480     //6. If its swaped in portait mode switch not normal portrait mode

   481     mView->mEffectHandler->mSwapInProgress = true;

   482     mView->mSharedVideoWidget->setGeometry(pos2);

   483     mView->mReceivedVideoWidget->setGeometry(pos1);

   484     layout = mView->currentLayout();

   485     QVERIFY( layout == lcLayoutPortraitDefaultId );

   486 

   487 }

   488 

   489 

   490 void UT_LcView::testActivateFullScreen()

   491 {

   492     QString layout;

   493     UT_SET_ORIENTATION( Qt::Horizontal );

   494 

   495     // Test1: Initial Layout is Vertical

   496     mEngine->setFullScreenMode(false);

   497     mView->activateFullScreen();

   498     QVERIFY( !mEngine->fullScreenMode());

   499 

   500     mView->init();

   501     mView->mEndCallButton = mEndCallButton;

   502     mEngine->setFullScreenMode(false);

   503     mView->activateFullScreen();

   504     QVERIFY( mEngine->fullScreenMode());

   505 

   506     QVERIFY( !mView->isItemVisible(Hb::TitleBarItem ) );

   507     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   508     QVERIFY( !mView->mEndCallButton->isVisible());

   509 

   510     layout = mView->currentLayout();

   511     QVERIFY( layout == lcLayoutLandscapeDefaultId );

   512     

   513     

   514     // Test2: Retry Full Screen if already Enabled.

   515     QVERIFY( mEngine->fullScreenMode());

   516     layout = mView->currentLayout();

   517     QVERIFY( layout == lcLayoutLandscapeDefaultId );

   518     

   519 }

   520 

   521 void UT_LcView::testDeactivateFullScreen()

   522 {

   523     mView->init();

   524     mView->mEndCallButton = mEndCallButton;

   525     QString layout;

   526     UT_SET_ORIENTATION( Qt::Horizontal );

   527     layout = mView->currentLayout();

   528     

   529     // Test2: Deactivate from Full Screen Mode

   530     mEngine->setFullScreenMode(true);

   531     mView->deActivateFullScreen();

   532 

   533     QVERIFY( !mEngine->fullScreenMode());

   534     QVERIFY( mView->isTitleBarVisible() );

   535     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   536     QVERIFY( mView->mEndCallButton->isVisible());

   537 

   538     QVERIFY( layout == lcLayoutLandscapeDefaultId );

   539 

   540     // Test2: Trying to Deactivate full sceeen 

   541     // when its not full screen

   542     mEngine->setFullScreenMode(false);

   543     mView->deActivateFullScreen();

   544     

   545     QVERIFY( mView->isTitleBarVisible() );

   546     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   547     QVERIFY( mView->mEndCallButton->isVisible());

   548     QVERIFY( layout == lcLayoutLandscapeDefaultId );

   549 }

   550 

   551 

   552 void UT_LcView::testGestureEvent()

   553 {

   554     mView->init();

   555     UT_SET_ORIENTATION( Qt::Horizontal );

   556     mView->mItemContextMenu = 0;

   557     mView->mSharedVideoWidget->setGeometry(QRectF(5,50, 100, 100));

   558     mView->mReceivedVideoWidget->setGeometry(QRectF(5,200, 200, 400));

   559     QList<QGesture*> list;

   560     

   561     // Test1: Short tap Event anywhere on screen

   562     mEngine->setFullScreenMode(true);

   563     QPointF sharedVideoPos(10,60);

   564     QTapGesture *tapGesture = new QTapGesture();

   565     tapGesture->setPosition(sharedVideoPos);

   566     HbStubHelper::setGestureStyleHint(HbTapGesture::Tap);

   567     HbStubHelper::setGestureState(Qt::GestureFinished);

   568     list.append(tapGesture);

   569     QGestureEvent event1(list);

   570     mView->gestureEvent(&event1);

   571     QVERIFY( !mEngine->fullScreenMode());

   572     // no contet menu

   573     QVERIFY( !mView->mItemContextMenu );

   574     mView->mItemContextMenu = 0;

   575     list.clear();

   576     

   577     // Test2: Long tap event on Shared Video Widget.

   578     UT_SET_ORIENTATION( Qt::Vertical );

   579     QTapGesture *tapGesture1 = new QTapGesture();

   580     tapGesture1->setPosition(sharedVideoPos);

   581     HbStubHelper::setGestureState(Qt::GestureUpdated);

   582     HbStubHelper::setGestureStyleHint(HbTapGesture::TapAndHold);

   583     list.append(tapGesture1);

   584     QGestureEvent event2(list);

   585     mEngine->setFullScreenMode(true);

   586     mView->gestureEvent(&event2);

   587     // No affect to the full screen mode it remains same  

   588     QVERIFY( mEngine->fullScreenMode());

   589     // Ensure context menu is created

   590     QVERIFY( mView->mItemContextMenu );

   591     list.clear();

   592     mView->mItemContextMenu = 0;

   593     

   594     // Test3: Long tap event on Received Video Widget

   595     UT_SET_ORIENTATION( Qt::Vertical );

   596     QTapGesture *tapGesture2 = new QTapGesture();

   597     QPointF receivedVideoPos(10,210);

   598     tapGesture2->setPosition(receivedVideoPos);

   599     HbStubHelper::setGestureState(Qt::GestureUpdated);

   600     HbStubHelper::setGestureStyleHint(HbTapGesture::TapAndHold);

   601     list.append(tapGesture2);

   602     QGestureEvent event3(list);

   603     mEngine->setFullScreenMode(true);

   604     mView->gestureEvent(&event3);

   605     // Ensure it does not affect full screen mode.

   606     QVERIFY( mEngine->fullScreenMode());

   607     QVERIFY( !mView->mItemContextMenu );

   608     

   609     //Test4: Not Handled States.

   610     HbStubHelper::setGestureState(Qt::GestureStarted);

   611     mEngine->setFullScreenMode(true);

   612     mView->gestureEvent(&event3);

   613     // Ensure its not handled everything remains same

   614     QVERIFY( mEngine->fullScreenMode());

   615     QVERIFY( !mView->mItemContextMenu );

   616     list.clear();

   617     

   618     //Test5: Not Handled Event

   619     QSwipeGesture *swipeGesture = new QSwipeGesture();

   620     list.append(swipeGesture);

   621     QGestureEvent event4(list);

   622     mEngine->setFullScreenMode(true);

   623     mView->gestureEvent(&event4);

   624     // Ensure it does not affect full screen mode.

   625     QVERIFY( mEngine->fullScreenMode());

   626     QVERIFY( !mView->mItemContextMenu );

   627 

   628 }

   629 

   630 void UT_LcView::testContextMenu()

   631 {

   632     QVERIFY( !mView->mItemContextMenu );    

   633     mView->createContextMenu();

   634     QVERIFY( mView->mItemContextMenu );

   635     QVERIFY( mView->mItemContextMenu->isEmpty() );

   636 }

   637 

   638 void UT_LcView::testGestureLongPress()

   639 {

   640     QVERIFY( !mView->mItemContextMenu );

   641     QPointF coordsNoHit(10,10);    

   642     mView->gestureLongPress( coordsNoHit );

   643     QVERIFY( !mView->mItemContextMenu );

   644     

   645     mView->init();

   646     HbTransparentWindow* sharedVideoWidget = mView->mSharedVideoWidget;

   647     QVERIFY( sharedVideoWidget != NULL );

   648     mView->mSharedVideoWidget->setGeometry(QRectF(5,100, 200, 200));

   649     

   650     QPointF coordsHitSharedVideo(20,150);    

   651     mView->gestureLongPress( coordsHitSharedVideo );

   652     QVERIFY( mView->mItemContextMenu );

   653     

   654     delete mView->mItemContextMenu;

   655     mView->mItemContextMenu = 0;

   656     

   657     QPointF coordsNoHit2(10,400);    

   658     mView->gestureLongPress( coordsNoHit2 );

   659     QVERIFY( !mView->mItemContextMenu );

   660 

   661     HbTransparentWindow* receivedVideoWidget = mView->mReceivedVideoWidget;

   662     QVERIFY( receivedVideoWidget != NULL );

   663     mView->mReceivedVideoWidget->setGeometry(QRectF(5,350, 200, 200));

   664 

   665     QPointF coordsHitRecievedVideo(10,400);    

   666     mView->gestureLongPress( coordsHitRecievedVideo );

   667     QVERIFY( !mView->mItemContextMenu );

   668 }

   669 

   670 

   671 void UT_LcView::testGestureShortPress()

   672 {

   673     mView->init();

   674     mView->mSharedVideoWidget->setGeometry(QRectF(5,50, 100, 100));

   675     mView->mReceivedVideoWidget->setGeometry(QRectF(5,200, 200, 400));

   676  

   677     UT_SET_ORIENTATION( Qt::Horizontal );

   678     mEngine->setFullScreenMode(true);

   679     mView->gestureShortPress();

   680     QVERIFY( !mEngine->fullScreenMode());

   681     

   682     // toggled

   683     mView->gestureShortPress();

   684     QVERIFY( mEngine->fullScreenMode());

   685 

   686     // no action if its not landscape.

   687     UT_SET_ORIENTATION( Qt::Vertical );

   688     mView->gestureShortPress();

   689     QVERIFY( mEngine->fullScreenMode());

   690 }

   691 

   692 

   693 

   694 void UT_LcView::testActivatePortrait()

   695 {

   696 

   697     mView->activatePortrait();

   698 

   699     mView->init();

   700     mView->mEndCallButton = mEndCallButton;

   701     mView->activateFullScreen();

   702     QVERIFY( mEngine->fullScreenMode());

   703     QVERIFY( !mView->isTitleBarVisible() );

   704     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   705     QVERIFY( !mView->mEndCallButton->isVisible());

   706 

   707     mView->activatePortrait();

   708     QVERIFY( !mEngine->fullScreenMode());

   709     QVERIFY( mView->isTitleBarVisible() );

   710     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   711     QVERIFY( mView->mEndCallButton->isVisible());

   712 

   713 }

   714 

   715 void UT_LcView::testUpdateUiElements()

   716 {

   717     mView->init();

   718     UT_SET_ORIENTATION( Qt::Horizontal );

   719     mView->updateUiElements();

   720     QVERIFY( !mEngine->fullScreenMode());

   721     QVERIFY( mView->isTitleBarVisible() );

   722     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   723 

   724     UT_SET_ORIENTATION( Qt::Vertical );

   725     mView->updateUiElements();

   726     QVERIFY( !mEngine->fullScreenMode());

   727     QVERIFY( mView->isTitleBarVisible() );

   728     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   729 }

   730 

   731 void UT_LcView::testLandscapeTimerTimeout()

   732 {

   733     mView->init();

   734     mView->deActivateFullScreen();

   735 

   736     // No effect as in vertical zontal mode

   737     UT_SET_ORIENTATION(Qt::Vertical);

   738     QVERIFY( !mEngine->fullScreenMode());

   739     QVERIFY( mView->isTitleBarVisible() );

   740     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   741 

   742     mView->landscapeTimerTimeout();

   743     QVERIFY( !mEngine->fullScreenMode());

   744     QVERIFY( mView->isTitleBarVisible() );

   745     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   746     

   747     // Effective in horizontal mode

   748     UT_SET_ORIENTATION(Qt::Horizontal);

   749     mView->landscapeTimerTimeout();

   750     

   751     QVERIFY( mEngine->fullScreenMode());

   752     QVERIFY( !mView->isTitleBarVisible() );

   753     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   754 

   755     // Test: If menu is open than it should not go into full screen mode.

   756     mView->deActivateFullScreen();

   757     mView->mIsOptionMenuOpen = true;

   758     mView->landscapeTimerTimeout();

   759     QVERIFY( !mEngine->fullScreenMode());

   760     QVERIFY( mView->isTitleBarVisible() );

   761     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   762 }

   763 

   764 void UT_LcView::testShareImage()

   765 {

   766     QVERIFY( !lcutStub_LcUiEngine_isImageShared );

   767     mView->shareImage();

   768     //QVERIFY( lcutStub_LcUiEngine_isImageShared() );

   769 }

   770 

   771 

   772 void UT_LcView::testShowControl()

   773 {

   774     mView->showControl();

   775     QVERIFY( mView->isTitleBarVisible() );

   776     QVERIFY( mView->toolBar()->isVisible() );

   777     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   778     QVERIFY( mView->mEndCallButton->isVisible());

   779     QVERIFY( mView->mRecipient->isVisible());

   780 }

   781 

   782 void UT_LcView::testHideControl()

   783 {

   784     mView->hideControl();

   785     QVERIFY( !mView->isTitleBarVisible() );

   786     QVERIFY( !mView->toolBar()->isVisible() );

   787     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   788     QVERIFY( !mView->mEndCallButton->isVisible());

   789     QVERIFY( !mView->mRecipient->isVisible());

   790 }

   791 

   792 void UT_LcView::testUpdateSwapLayout()

   793 {

   794     //Test1: In Full Screen Mode controls Should be hidden.

   795     mView->init();

   796     mView->mEndCallButton = mEndCallButton;

   797     UT_SET_ORIENTATION( Qt::Horizontal );

   798     mEngine->setFullScreenMode(true);

   799 

   800     mView->updateSwapLayout();

   801     QVERIFY( !mView->isItemVisible(Hb::TitleBarItem ) );

   802     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   803     QVERIFY( !mView->mEndCallButton->isVisible());

   804 

   805     // Test2: If its not full screen show the controls

   806     mEngine->setFullScreenMode(false);

   807     mView->updateSwapLayout();

   808     QVERIFY( mView->isTitleBarVisible() );

   809     QVERIFY( !mView->isItemVisible(Hb::DockWidgetItem ) );

   810     QVERIFY( mView->mEndCallButton->isVisible());

   811 }

   812 

   813 void UT_LcView::testMenuAboutToShow()

   814 {

   815     mView->init();

   816     QVERIFY( !mView->mIsOptionMenuOpen  );

   817     mView->menuAboutToShow();

   818     QVERIFY( mView->mIsOptionMenuOpen  );

   819     QVERIFY( !mView->mLandscapeTimer->isActive());

   820 

   821 }

   822 

   823 void UT_LcView::testMenuAboutToHide()

   824 {

   825     mView->init();

   826     mView->menuAboutToHide();

   827     QVERIFY( !mView->mIsOptionMenuOpen  );

   828     QVERIFY( mView->mLandscapeTimer->isActive());

   829 }

   830 

   831 void UT_LcView::testTranslateRectForOrientation()

   832 {

   833     UT_SET_ORIENTATION( Qt::Vertical );

   834     QRectF origRect( 10, 10, 100, 200 );

   835     

   836     QRectF modRect = mView->translateRectForOrientation(origRect);

   837     QVERIFY( origRect == modRect );

   838     

   839     UT_SET_ORIENTATION( Qt::Horizontal );

   840     modRect = mView->translateRectForOrientation(origRect);

   841     QVERIFY( modRect.height() == origRect.width() );

   842     QVERIFY( modRect.width() == origRect.height() );

   843 }

   844 

   845 void UT_LcView::testTranslatePointForOrientation()

   846 {

   847     UT_SET_ORIENTATION( Qt::Vertical );

   848     QPointF origPoint( 10, 20 );

   849     

   850     QPointF modPoint = mView->translatePointForOrientation(origPoint);

   851     QVERIFY( origPoint == modPoint );

   852     

   853     UT_SET_ORIENTATION( Qt::Horizontal );

   854     modPoint = mView->translatePointForOrientation(origPoint);

   855     QVERIFY( origPoint != modPoint );

   856 }

   857 

   858 void UT_LcView::testResetLandscapeTimer()

   859 {

   860     // No timer

   861     QVERIFY( !mView->mLandscapeTimer );

   862     mView->resetLandscapeTimer();

   863     QVERIFY( !mView->mLandscapeTimer );

   864     

   865     // Timer not acitve

   866     mView->mLandscapeTimer = new QTimer();

   867     QVERIFY( !mView->mLandscapeTimer->isActive() );

   868     mView->resetLandscapeTimer();

   869     QVERIFY( !mView->mLandscapeTimer->isActive() );

   870 

   871     // Timer is active

   872     mView->mLandscapeTimer->start();

   873     int oldTimerId = mView->mLandscapeTimer->timerId();

   874     mView->resetLandscapeTimer();

   875     QVERIFY( mView->mLandscapeTimer->isActive() );

   876     QVERIFY( oldTimerId != mView->mLandscapeTimer->timerId() );

   877 }

   878 

   879 void  UT_LcView::testOpenDialpad()

   880 {

   881     delete mView;

   882     mView = mRepository->twowayView();

   883     HbMainWindow& window = *(HbInstance::instance()->allMainWindows().at(0));  

   884     QPointF pos = window.pos();

   885     window.setOrientation(Qt::Horizontal);

   886     

   887     // init

   888     mView->mRepository.mLayoutSection = lcLayoutLandscapeDefaultId;

   889     mView->menu()->setVisible(true);

   890     

   891     mView->openDialpad();

   892     

   893     QVERIFY(mView->mDialpad->isOpen());   

   894     QVERIFY(mView->mRepository.mLayoutSection == lcLayoutLandscapeDialpadId);    

   895     QVERIFY(mView->isTitleBarVisible());

   896     QCOMPARE(mView->menu()->actions().size(), 0);

   897     QVERIFY(!mView->mLandscapeTimer->isActive());

   898     QVERIFY(!mView->mEngine.fullScreenMode());

   899 }

   900 

   901 void  UT_LcView::testDialpadOpened()

   902 {

   903     // no implementation

   904 }

   905 

   906 void  UT_LcView::testDialpadClosed()

   907 {

   908     delete mView;

   909     mView = mRepository->twowayView();

   910     

   911     // test : no fullscreen,landscape , open and close dialpad scenario     

   912     HbMainWindow& window = *(HbInstance::instance()->allMainWindows().at(0));  

   913     window.setOrientation( Qt::Horizontal );

   914     mView->openDialpad();    

   915     mView->dialpadClosed();

   916     // check that layout has changed

   917     QVERIFY(mView->mRepository.layout()!= lcLayoutLandscapeDialpadId);

   918     QVERIFY(mView->isTitleBarVisible());

   919     QVERIFY(mView->toolBar()->isVisible());

   920     QVERIFY(mView->mEndCallButton->isVisible());

   921     QVERIFY(mView->mRecipient->isVisible());

   922     QVERIFY(mView->mDuration->isVisible());    

   923     QVERIFY(mView->menu()->isVisible());

   924     QVERIFY(mView->mLandscapeTimer->isActive());

   925     QVERIFY(!mView->mEngine.fullScreenMode());

   926     

   927     // test : swapped,fullscreen,landscape,open and close dialpad scenario

   928     mView->mRepository.loadLayout( lcLayoutLandscapeSwappedId );    

   929     mView->openDialpad();

   930     mView->dialpadClosed();

   931     // check for swapped view appears

   932     QVERIFY( mView->mRepository.layout()== lcLayoutLandscapeSwappedId );   

   933     // check titlebar invisible

   934     QVERIFY( mView->isTitleBarVisible() );

   935     // check toolbar invisible

   936     QVERIFY( mView->toolBar()->isVisible() );

   937     QVERIFY(mView->mLandscapeTimer->isActive());

   938     QVERIFY(!mView->mEngine.fullScreenMode());

   939     

   940     // test : orientation to portrait 

   941     //        swapped,fullscreen,landscape,open and close dialpad scenario

   942     mView->mRepository.loadLayout( lcLayoutLandscapeSwappedId );    

   943     mView->openDialpad();

   944     window.setOrientation( Qt::Vertical );

   945     mView->dialpadClosed();

   946     // check for swapped view appears

   947     QVERIFY( mView->mRepository.layout()== lcLayoutPortraitSwappedId );

   948     // check titlebar visible

   949     QVERIFY( mView->isTitleBarVisible() );

   950     // check toolbar visible

   951     QVERIFY( mView->toolBar()->isVisible() );

   952     QVERIFY(!mView->mLandscapeTimer->isActive());

   953     QVERIFY(!mView->mEngine.fullScreenMode());

   954     

   955 }

   956 

   957 

   958 void  UT_LcView::testDialpadEditorTextChanged()

   959 {   

   960     delete mView;

   961     mView = mRepository->twowayView();

   962     

   963     mView->openDialpad();

   964     //text editor is one character long

   965     QVERIFY( lcutStub_LcUiEngine_getDialToneChar() == '0');

   966     mView->mDialpad->editor().setText( QString("1") );

   967     mView->dialpadEditorTextChanged();

   968     QVERIFY( lcutStub_LcUiEngine_getDialToneChar() == '1' );

   969 

   970     // We transmit dial tone character sepretly.

   971     mView->mDialpad->editor().setText( QString("12345") );

   972     mView->dialpadEditorTextChanged();

   973     QVERIFY( lcutStub_LcUiEngine_getDialToneChar() == '5' );

   974 }

   975 

   976 void  UT_LcView::testBack()

   977 {       

   978     delete mView;

   979     mView = mRepository->twowayView();    

   980     mView->openDialpad();

   981     mView->back();

   982     QVERIFY( !mView->mDialpad->isOpen() );    

   983 }

   984 

   985 void UT_LcView::testAddOptionsMenuActions()

   986 {

   987     delete mView;

   988     mView = mRepository->twowayView();

   989     

   990     mView->addOptionsMenuActions();

   991     //TODO: stub implementation of void QGraphicsWidget::addAction(QAction *action);

   992     //QCOMPARE(mView->menu()->actions().size(), 2);

   993 }