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:  Unit tests for PhoneUIQtViewAdapter.

    15 *

    16 */

    17 

    18 #include <QtTest/QtTest>

    19 #include <QtGui>

    20 #include <QList>

    21 #include <QKeyEvent>

    22 #include <QSignalSpy>

    23 #include <HbApplication>

    24 #include <xqcallinfo.h>

    25 #include <callinformation.h>

    26 #include <MediatorDomainUIDs.h>

    27 #include <telinformationpskeys.h>

    28 #include <coreapplicationuisdomainpskeys.h>

    29 #include <ccallinfoiter.h>

    30 #include <keyguardaccessapi.h>

    31 #include "phoneuiqtviewif.h"

    32 #define private public

    33 #include "phonevisibilityhandler.h"

    34 #undef public

    35 

    36 int m_callCount = 0;

    37 int g_keyGuardEnabled = false;

    38 int g_enableKeyGuardCalled = false;

    39 int g_disableKeyGuardCalled = false;

    40 

    41 #define PHONE_TEST_MAIN(TestObject) \

    42 int main(int argc, char *argv[]) \

    43     { \

    44         HbApplication app(argc, argv); \

    45         TestObject tc; \

    46         QResource::registerResource("../hbcore.rcc"); \

    47         int ret = QTest::qExec(&tc, argc, argv); \

    48         /* Core dump if HbIconLoader instance is not destroyed before the application instance. */ \

    49         /* HbIconLoader uses QCoreApplication::aboutToQuit() signal to destroy itself. */ \

    50         /* app.exec() where the signal is normally emitted is not called here. */ \

    51         /* So, invoking the signal explicitly. */ \

    52         QMetaObject::invokeMethod(&app, "aboutToQuit", Qt::DirectConnection); \

    53         return ret; \

    54     }

    55 

    56 TInt CCallInfoIter::Count() const

    57 {

    58     return m_callCount;

    59 }

    60 

    61 class TestPhoneVisibilityHandler : public QObject, public PhoneUIQtViewIF

    62 {

    63     Q_OBJECT

    64 public:

    65     TestPhoneVisibilityHandler();

    66     virtual ~TestPhoneVisibilityHandler();

    67 

    68     // From PhoneUIQtViewIF

    69     BubbleManagerIF& bubbleManager () {};

    70     void addBubbleCommand (int , const PhoneAction& ) {};

    71     void clearBubbleCommands (int ) {};

    72     void addParticipantListAction(

    73             int ,  

    74             const QString &, 

    75             const HbIcon &) {};

    76     void clearParticipantListActions() {};

    77     void hideToolbar () {};

    78     void showToolbar () {};

    79     void setToolbarActions (const QList<PhoneAction*>& ) {};

    80     int volumeSliderValue () {};

    81     void removeVolumeSlider () {};

    82     void setVolumeSliderValue (

    83             int , 

    84             int , 

    85             int , 

    86             int  ) {};

    87 

    88     void setExpandAction(int , int ) {};

    89     void removeExpandAction(int ) {};

    90     void showDialpad() {};

    91     void hideDialpad() {};

    92     bool isDialpadVisible() {};

    93     QString dialpadText() {};

    94     void clearAndHideDialpad() {};

    95     void clearDialpad() {};

    96     void bringToForeground() { m_bringToForegroundCalled = true;};

    97     void setMenuActions(const QList<PhoneAction*>& ) {};

    98     void shutdownPhoneApp() {};

    99     void setBackButtonVisible(bool ) {};

   100     HbMenu &menuReference() {};

   101     void captureKey(Qt::Key , bool ) {};

   102     void setRestrictedMode(bool ) {};

   103     

   104 public slots:

   105     void initTestCase();

   106 

   107     void cleanupTestCase();

   108 

   109     void init();

   110 

   111     void cleanup();

   112     

   113 private slots:

   114     void t_memleak();

   115     

   116     void t_normal();

   117     

   118     void t_carmode();

   119     

   120     void t_devicelock();

   121     

   122     void t_keyGuardHandling();

   123 

   124     

   125 private:

   126     PhoneVisibilityHandler *m_handler;

   127     bool m_bringToForegroundCalled;

   128     int m_startPosition;

   129     int m_startPriority;

   130     int m_normalPriority;

   131 };

   132 

   133 CKeyguardAccessApi* CKeyguardAccessApi::NewL()

   134 {

   135     return new CKeyguardAccessApi;

   136 }

   137 CKeyguardAccessApi::~CKeyguardAccessApi( ) {}

   138 CKeyguardAccessApi::CKeyguardAccessApi( ) {}

   139 

   140 

   141 TBool CKeyguardAccessApi::IsKeyguardEnabled()

   142 {

   143     return g_keyGuardEnabled;

   144 }

   145 

   146 TInt CKeyguardAccessApi::EnableKeyguard( TBool  )

   147 {

   148     g_enableKeyGuardCalled = true;

   149     return 0;

   150 }

   151 

   152 TInt CKeyguardAccessApi::DisableKeyguard( TBool  )

   153 {

   154     g_disableKeyGuardCalled = true;

   155     return 0;

   156 }

   157 

   158 

   159 

   160 TestPhoneVisibilityHandler::TestPhoneVisibilityHandler ()

   161 {

   162 }

   163 

   164 TestPhoneVisibilityHandler::~TestPhoneVisibilityHandler ()

   165 {

   166 }

   167 

   168 void TestPhoneVisibilityHandler::initTestCase ()

   169 {

   170     m_normalPriority = CEikonEnv::Static()->RootWin().OrdinalPriority();

   171     

   172     m_handler = new PhoneVisibilityHandler (*this, this);

   173     

   174     m_startPosition = CEikonEnv::Static()->RootWin().OrdinalPosition();

   175     QVERIFY(m_startPosition > 0); // Expect OrdinalPosition higher than 0

   176     m_startPriority = CEikonEnv::Static()->RootWin().OrdinalPriority();

   177     QCOMPARE(m_startPriority, (int)ECoeWinPriorityNeverAtFront);

   178 }

   179 

   180 void TestPhoneVisibilityHandler::cleanupTestCase ()

   181 {

   182     delete m_handler;

   183 }

   184 

   185 void TestPhoneVisibilityHandler::init ()

   186 {

   187 

   188 }

   189 

   190 void TestPhoneVisibilityHandler::cleanup ()

   191 {

   192     g_keyGuardEnabled = false;

   193     g_enableKeyGuardCalled = false;

   194     g_disableKeyGuardCalled = false;

   195     m_bringToForegroundCalled = false;

   196 }

   197 

   198 void TestPhoneVisibilityHandler::t_memleak()

   199 {

   200 }

   201 

   202 void TestPhoneVisibilityHandler::t_normal()

   203 {

   204     // Test hide device dialogs when background ( false )

   205     m_handler->hideDeviceDialogs(false);

   206     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   207     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   208     

   209     // Test hide device dialogs when background ( true )

   210     m_handler->hideDeviceDialogs(true);

   211     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   212     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   213     

   214     // bringToForeground is call

   215     m_handler->bringToForeground();

   216     QVERIFY(m_bringToForegroundCalled);

   217     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   218     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   219     

   220     // Test hide device dialogs when foreground ( false )

   221     m_handler->hideDeviceDialogs(false);

   222     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   223     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_normalPriority);

   224 

   225     // Test hide device dialogs when foreground ( true )

   226     m_handler->hideDeviceDialogs(true);

   227     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   228     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   229     

   230     // send backgroud is called last

   231     m_handler->sendToBackground(false);

   232     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   233     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   234 }

   235 

   236 void TestPhoneVisibilityHandler::t_carmode()

   237 {

   238     QValueSpaceSubscriber* subscriber = new QValueSpaceSubscriber("/phone/carmode", this);

   239     QValueSpacePublisher* publisher = new QValueSpacePublisher("/phone",this);

   240 

   241     QVERIFY(m_handler->m_carModeEnabled == false);

   242     

   243     // 1 ongoing call and car mode switched on

   244     m_callCount = 1;

   245     publisher->setValue(QString("/carmode"),QVariant(true));

   246     QTest::qWait(100);

   247     QVERIFY(m_handler->m_carModeEnabled == true);

   248     QVERIFY(m_bringToForegroundCalled == false);

   249 

   250     // 1 ongoing call and car mode switched off

   251     publisher->setValue(QString("/carmode"),QVariant(false));

   252     QTest::qWait(100);

   253     QVERIFY(m_handler->m_carModeEnabled == false);

   254     QVERIFY(m_bringToForegroundCalled == true);

   255     

   256     // 0 ongoing calls and car mode switched on

   257     m_callCount = 0;

   258     m_bringToForegroundCalled = false;

   259     publisher->setValue(QString("/carmode"),QVariant(true));

   260     QTest::qWait(100);

   261     QVERIFY(m_handler->m_carModeEnabled == true);

   262     QVERIFY(m_bringToForegroundCalled == false);

   263 

   264     // 0 ongoing calls and car mode switched off

   265     publisher->setValue(QString("/carmode"),QVariant(false));

   266     QTest::qWait(100);

   267     QVERIFY(m_handler->m_carModeEnabled == false);

   268     QVERIFY(m_bringToForegroundCalled == false);

   269     

   270     // send backgroud is called last

   271     m_handler->sendToBackground(false);

   272     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   273     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   274 }

   275 

   276 void TestPhoneVisibilityHandler::t_devicelock()

   277 {

   278     m_handler->HandlePropertyChangedL(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, ETimerLocked);

   279     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   280     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   281     

   282     // Test hide device dialogs when background ( false )

   283     m_handler->hideDeviceDialogs(false);

   284     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   285     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   286     

   287     // Test hide device dialogs when background ( true )

   288     m_handler->hideDeviceDialogs(true);

   289     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   290     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   291     

   292     // bringToForeground is call

   293     m_handler->bringToForeground();

   294     QVERIFY(m_bringToForegroundCalled);

   295     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   296     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   297     

   298     // Test hide device dialogs when foreground ( false )

   299     m_handler->hideDeviceDialogs(false);

   300     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   301     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), (int)ECoeWinPriorityAlwaysAtFront);

   302 

   303     // Test hide device dialogs when foreground ( true )

   304     m_handler->hideDeviceDialogs(true);

   305     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   306     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   307     

   308     // Test lock status change

   309     m_handler->HandlePropertyChangedL(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);

   310     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   311     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   312 

   313     

   314     // send backgroud is called last

   315     m_handler->sendToBackground(false);

   316     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   317     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   318     

   319 }

   320 

   321 

   322 void TestPhoneVisibilityHandler::t_keyGuardHandling()

   323 {

   324     // Test when keyguard is not enabled before call

   325     g_keyGuardEnabled = false; 

   326     

   327     // bringToForeground is call

   328     m_handler->bringToForeground();

   329     QVERIFY(m_bringToForegroundCalled);

   330     QVERIFY(g_disableKeyGuardCalled);

   331     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   332     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   333     

   334     cleanup();

   335     // send backgroud is called last

   336     m_handler->sendToBackground(false);

   337     QVERIFY(!g_enableKeyGuardCalled);

   338     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   339     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   340     

   341     

   342     // Test when keyguard is enabled before call

   343     cleanup();

   344     g_keyGuardEnabled = true; 

   345     

   346     // bringToForeground is call

   347     m_handler->bringToForeground();

   348     QVERIFY(m_bringToForegroundCalled);

   349     QVERIFY(g_disableKeyGuardCalled);

   350     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   351     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   352     

   353     cleanup();

   354     // send backgroud is called last

   355     m_handler->sendToBackground(false);

   356     QVERIFY(g_enableKeyGuardCalled);

   357     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   358     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   359     

   360     // Test when keyguard is enabled before call +

   361     // keyguard is not enabled when phone is background

   362     cleanup();

   363     g_keyGuardEnabled = true;

   364     

   365     // bringToForeground is call

   366     m_handler->bringToForeground();

   367     QVERIFY(m_bringToForegroundCalled);

   368     QVERIFY(g_disableKeyGuardCalled);

   369     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   370     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   371 

   372     cleanup();

   373     // Test that keyguard is not enabled when phone is background

   374     CEikonEnv::Static()->RootWin().SetOrdinalPosition(-1, ECoeWinPriorityNormal);

   375     m_handler->sendToBackground(false);

   376     QVERIFY(!g_enableKeyGuardCalled);

   377     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   378     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   379     

   380     

   381     // Test case where two calls is created and key guard is enabled

   382     cleanup();

   383     g_keyGuardEnabled = true; 

   384     

   385     // bringToForeground is call

   386     m_handler->bringToForeground();

   387     QVERIFY(m_bringToForegroundCalled);

   388     QVERIFY(g_disableKeyGuardCalled);

   389     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   390     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   391     

   392     cleanup();

   393     m_handler->bringToForeground();

   394     QVERIFY(m_bringToForegroundCalled);

   395     QVERIFY(g_disableKeyGuardCalled);

   396     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   397     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   398     

   399     cleanup();

   400     m_handler->sendToBackground(false);

   401     QVERIFY(g_enableKeyGuardCalled);

   402     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   403     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   404     

   405     // Test case where two calls is created and key guard is enabled during middle

   406     cleanup();

   407     

   408     // bringToForeground is call

   409     m_handler->bringToForeground();

   410     QVERIFY(m_bringToForegroundCalled);

   411     QVERIFY(g_disableKeyGuardCalled);

   412     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   413     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   414     

   415     cleanup();

   416     g_keyGuardEnabled = true; 

   417     m_handler->bringToForeground();

   418     QVERIFY(m_bringToForegroundCalled);

   419     QVERIFY(g_disableKeyGuardCalled);

   420     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), 0);

   421     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), ECoeWinPriorityAlwaysAtFront + 100);

   422     

   423     cleanup();

   424     m_handler->sendToBackground(false);

   425     QVERIFY(g_enableKeyGuardCalled);

   426     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPosition(), m_startPosition);

   427     QCOMPARE(CEikonEnv::Static()->RootWin().OrdinalPriority(), m_startPriority);

   428 }

   429 

   430 

   431 PHONE_TEST_MAIN(TestPhoneVisibilityHandler)

   432 #include "unit_tests.moc"