Mercurial Mercurial > oss > FCL > sf > app > videoplayer / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
videoplayback/videoplaybackview/tsrc/testuserinputhandler/src/testuserinputhandler.cpp
changeset 62 0e1e938beb1a
parent 59 a76e86df7ccd
equal deleted inserted replaced
59:a76e86df7ccd 62:0e1e938beb1a 
     1 /**
 
     1 /**
 
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
     3 * All rights reserved.
 
     3 * All rights reserved.
 
     4 * This component and the accompanying materials are made available
 
     4 * This component and the accompanying materials are made available
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     6 * which accompanies this distribution, and is available
 
     6 * which accompanies this distribution, and is available
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    10 * Nokia Corporation - initial contribution.
 
    10 * Nokia Corporation - initial contribution.
 
    11 *
 
    11 *
 
    12 * Contributors:
 
    12 * Contributors:
 
    13 *
 
    13 *
 
    14 * Description:   tester for methods in User Input Handler
 
    14 * Description:   tester for methods in User Input Handler
 
    15 * 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 #include <e32err.h>
 
    18 #include <e32err.h>
 
    19 #include <w32std.h>
 
    19 #include <w32std.h>
 
    20 #include <eikenv.h>
 
    20 #include <eikenv.h>
 
    21 
    21 
       
    22 #include <e32property.h>
 
       
    23 #include <centralrepository.h>  
       
    24 #include <settingsinternalcrkeys.h> 
       
    25 #include <avkondomainpskeys.h>
 
       
    26 
    22 #include <hbapplication.h>
 
    27 #include <hbapplication.h>
 
    23 #include <hbinstance.h>
 
    28 #include <hbinstance.h>
 
    24 #include <QDebug>
 
    29 #include <QDebug>
 
    25 
    30 
    26 #include "testuserinputhandler.h"
 
    31 #include "testuserinputhandler.h"
 
    38 //
 
    43 //
 
    39 int main(int argc, char *argv[])
 
    44 int main(int argc, char *argv[])
 
    40 {
 
    45 {
 
    41     HbApplication app(argc, argv);
 
    46     HbApplication app(argc, argv);
 
    42     HbMainWindow window;
 
    47     HbMainWindow window;
 
    43     
    48 
    44     TestUserInputHandler tv;
 
    49     TestUserInputHandler tv;
 
    45 
    50 
    46     char *pass[3];
 
    51     char *pass[3];
 
    47     pass[0] = argv[0];
 
    52     pass[0] = argv[0];
 
    48     pass[1] = "-o";
 
    53     pass[1] = "-o";
 
    49     pass[2] = "c:\\data\\testuserinputhandler.txt";
 
    54     pass[2] = "c:\\data\\testuserinputhandler.txt";
 
    50     
    55 
    51     int res = QTest::qExec(&tv, 3, pass);
 
    56     int res = QTest::qExec(&tv, 3, pass);
 
    52     
    57 
    53     return res;
 
    58     return res;
 
    54 }
 
    59 }
 
    55 
       
    56 
    60 
    57 // ---------------------------------------------------------------------------
 
    61 // ---------------------------------------------------------------------------
 
    58 // init
 
    62 // init
 
    59 // ---------------------------------------------------------------------------
 
    63 // ---------------------------------------------------------------------------
 
    60 //
 
    64 //
 
    61 void TestUserInputHandler::init()
 
    65 void TestUserInputHandler::init()
 
    62 {	     
    66 {
 
    63     mBaseVideoView    = new VideoBasePlaybackView();
 
    67     mBaseVideoView    = new VideoBasePlaybackView();
 
    64     mVideoViewWrapper = CMPXVideoViewWrapper::NewL( mBaseVideoView );   
    68     mVideoViewWrapper = CMPXVideoViewWrapper::NewL( mBaseVideoView );
 
    65         
    69 
    66     mUserInputHdlr = CVideoPlaybackUserInputHandler::NewL(mVideoViewWrapper, false);
 
    70     mUserInputHdlr = CVideoPlaybackUserInputHandler::NewL( mVideoViewWrapper );
 
    67 }
 
    71 }
 
    68 
    72 
    69 // ---------------------------------------------------------------------------
 
    73 // ---------------------------------------------------------------------------
 
    70 // cleanup
 
    74 // cleanup
 
    71 // ---------------------------------------------------------------------------
 
    75 // ---------------------------------------------------------------------------
 
    72 //
 
    76 //
 
    73 void TestUserInputHandler::cleanup()
 
    77 void TestUserInputHandler::cleanup()
 
    74 {           
    78 {
 
    75     delete mUserInputHdlr;
 
    79     delete mUserInputHdlr;
 
    76     mUserInputHdlr = NULL;  
    80     mUserInputHdlr = NULL;
 
    77     
    81 
    78     delete mVideoViewWrapper;
 
    82     delete mVideoViewWrapper;
 
    79     mVideoViewWrapper = NULL;
 
    83     mVideoViewWrapper = NULL;
 
    80         
    84 
    81     delete mBaseVideoView;
 
    85     delete mBaseVideoView;
 
    82     mBaseVideoView = NULL;              
    86     mBaseVideoView = NULL;
 
    83 }
 
    87 }
 
    84 
    88 
    85 // ---------------------------------------------------------------------------
 
    89 // ---------------------------------------------------------------------------
 
    86 // setup
 
    90 // setup
 
    87 // ---------------------------------------------------------------------------
 
    91 // ---------------------------------------------------------------------------
 
    88 //
 
    92 //
 
    89 void TestUserInputHandler::setup()
 
    93 void TestUserInputHandler::setup()
 
    90 {    
    94 {
 
    91 }
 
    95 }
 
    92 
    96 
    93 void TestUserInputHandler::testProcessMediaKeyPlay()
 
    97 void TestUserInputHandler::testProcessMediaKeyPlay()
 
    94 {    
    98 {
 
    95     init();
 
    99     init();
 
    96     
   100 
    97     mUserInputHdlr->iProcessingInputType = EVideoNone;    
   101     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
    98     
   102 
    99     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   103     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   100     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   104     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   101     
   105 
   102     // this event should be ignored as the 1st event is still being processed
 
   106     // this event should be ignored as the 1st event is still being processed
 
   103     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPause, ERemConCoreApiButtonPress);
 
   107     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPause, ERemConCoreApiButtonPress);
 
   104     
   108 
   105     // verify that "Play" is still being processed and not "Pause"
 
   109     // verify that "Play" is still being processed and not "Pause"
 
   106     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiPlay );
 
   110     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiPlay );
 
   107     
   111 
   108     // send the release event for "Play"
 
   112     // send the release event for "Play"
 
   109     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   113     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   110     
   114 
   111     // verify that no input is now being processed
 
   115     // verify that no input is now being processed
 
   112     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   116     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   113     
   117 
   114     cleanup();
 
   118     cleanup();
 
   115 }
 
   119 }
 
   116 
   120 
   117 void TestUserInputHandler::testProcessMediaKeyPause()
 
   121 void TestUserInputHandler::testProcessMediaKeyPause()
 
   118 {    
   122 {
 
   119     init();
 
   123     init();
 
   120     
   124 
   121     mUserInputHdlr->iProcessingInputType = EVideoNone;    
   125     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
   122     
   126 
   123     // Issue Play
 
   127     // Issue Play
 
   124     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   128     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   125     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   129     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   126     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   130     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   127 
   131 
   128     // Initiate Pause
 
   132     // Initiate Pause
 
   129     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPause, ERemConCoreApiButtonPress);
 
   133     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPause, ERemConCoreApiButtonPress);
 
   130     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );    
   134     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   131     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiPause );    
   135     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiPause );
 
   132     
   136 
   133     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPause, ERemConCoreApiButtonRelease); 
   137     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPause, ERemConCoreApiButtonRelease);
 
   134     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   138     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   135     
   139 
   136     cleanup();    
   140     cleanup();
 
   137     
   141 
   138 }
 
   142 }
 
   139 
   143 
   140 void TestUserInputHandler::testProcessMediaKeyPlayPause()
 
   144 void TestUserInputHandler::testProcessMediaKeyPlayPause()
 
   141 {    
   145 {
 
   142     init();
 
   146     init();
 
   143     
   147 
   144     mUserInputHdlr->iProcessingInputType = EVideoNone;    
   148     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
   145     
   149 
   146     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPausePlayFunction, ERemConCoreApiButtonClick);
 
   150     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPausePlayFunction, ERemConCoreApiButtonClick);
 
   147     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );      
   151     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   148     
   152 
   149     // set to background
 
   153     // set to background
 
   150     mUserInputHdlr->iForeground = false;
 
   154     mUserInputHdlr->iForeground = false;
 
   151     
   155 
   152     mUserInputHdlr->iLastMediaKeyPressed = ENop;
 
   156     mUserInputHdlr->iLastMediaKeyPressed = ENop;
 
   153     // this event should be ignored as iForeground is false
 
   157     // this event should be ignored as iForeground is false
 
   154     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPausePlayFunction, ERemConCoreApiButtonPress);
 
   158     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPausePlayFunction, ERemConCoreApiButtonPress);
 
   155     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ENop );
 
   159     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ENop );
 
   156     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );     
   160     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   157     
   161 
   158     cleanup();       
   162     cleanup();
 
   159 }
 
   163 }
 
   160 
   164 
   161 void TestUserInputHandler::testProcessMediaKeyStop()
 
   165 void TestUserInputHandler::testProcessMediaKeyStop()
 
   162 {    
   166 {
 
   163     init();
 
   167     init();
 
   164     
   168 
   165     mUserInputHdlr->iProcessingInputType = EVideoNone;    
   169     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
   166     
   170 
   167     // Issue Play
 
   171     // Issue Play
 
   168     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   172     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   169     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   173     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   170     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   174     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   171 
   175 
   172     // Stop
 
   176     // Stop
 
   173     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiStop, ERemConCoreApiButtonPress);
 
   177     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiStop, ERemConCoreApiButtonPress);
 
   174     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );    
   178     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   175     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiStop );    
   179     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiStop );
 
   176     
   180 
   177     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiStop, ERemConCoreApiButtonRelease); 
   181     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiStop, ERemConCoreApiButtonRelease);
 
   178     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   182     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   179     
   183 
   180     cleanup();     
   184     cleanup();
 
   181 }
 
   185 }
 
   182 
   186 
   183 void TestUserInputHandler::testProcessMediaKeyForward()
 
   187 void TestUserInputHandler::testProcessMediaKeyForward()
 
   184 {    
   188 {
 
   185     init();
 
   189     init();
 
   186     
   190 
   187     mUserInputHdlr->iProcessingInputType = EVideoNone;    
   191     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
   188     
   192 
   189     // Issue Play
 
   193     // Issue Play
 
   190     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   194     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   191     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   195     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   192     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   196     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   193 
   197 
   194     // Forward
 
   198     // Forward
 
   195     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiFastForward, ERemConCoreApiButtonPress);
 
   199     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiFastForward, ERemConCoreApiButtonPress);
 
   196     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );    
   200     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   197     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiFastForward );    
   201     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiFastForward );
 
   198     
   202 
   199     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiFastForward, ERemConCoreApiButtonRelease); 
   203     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiFastForward, ERemConCoreApiButtonRelease);
 
   200     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   204     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   201     
   205 
   202     cleanup();     
   206     cleanup();
 
   203 }
 
   207 }
 
   204 
   208 
   205 void TestUserInputHandler::testProcessMediaKeyRewind()
 
   209 void TestUserInputHandler::testProcessMediaKeyRewind()
 
   206 {    
   210 {
 
   207     init();
 
   211     init();
 
   208     
   212 
   209     mUserInputHdlr->iProcessingInputType = EVideoNone;    
   213     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
   210     
   214 
   211     // Issue Play
 
   215     // Issue Play
 
   212     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   216     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   213     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   217     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   214     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   218     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   215 
   219 
   216     // Forward
 
   220     // Forward
 
   217     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiFastForward, ERemConCoreApiButtonPress);
 
   221     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiFastForward, ERemConCoreApiButtonPress);
 
   218     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );    
   222     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   219     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiFastForward );    
   223     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiFastForward );
 
   220     
   224 
   221     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiFastForward, ERemConCoreApiButtonRelease); 
   225     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiFastForward, ERemConCoreApiButtonRelease);
 
   222     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   226     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   223     
   227 
   224     // Rewind
 
   228     // Rewind
 
   225     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiRewind, ERemConCoreApiButtonPress);
 
   229     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiRewind, ERemConCoreApiButtonPress);
 
   226     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );    
   230     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   227     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiRewind );    
   231     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiRewind );
 
   228     
   232 
   229     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiRewind, ERemConCoreApiButtonRelease); 
   233     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiRewind, ERemConCoreApiButtonRelease);
 
   230     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   234     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   231     
   235 
   232     cleanup();     
   236     cleanup();
 
   233 }
 
   237 }
 
   234 
   238 
   235 void TestUserInputHandler::testProcessMediaKeyVolumeUp()
 
   239 void TestUserInputHandler::testProcessMediaKeyVolumeUp()
 
   236 {    
   240 {
 
   237     init();
 
   241     init();
 
   238     
   242 
   239     mUserInputHdlr->iProcessingInputType = EVideoNone;    
   243     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
   240     
   244 
   241     // Issue Play
 
   245     // Issue Play
 
   242     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   246     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   243     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   247     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   244     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   248     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   245     
   249 
   246     // Volume Up
 
   250     // Volume Up
 
   247     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeUp, ERemConCoreApiButtonPress);
 
   251     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeUp, ERemConCoreApiButtonPress);
 
   248     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );    
   252     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   249     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiVolumeUp );   
   253     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiVolumeUp );
 
   250     QVERIFY( mUserInputHdlr->iVolumeRepeatTimer->IsActive() );
 
   254     QVERIFY( mUserInputHdlr->iVolumeRepeatTimer->IsActive() );
 
   251     QVERIFY( mUserInputHdlr->iVolumeRepeatUp );
 
   255     QVERIFY( mUserInputHdlr->iVolumeRepeatUp );
 
   252     
   256 
   253     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeUp, ERemConCoreApiButtonRelease); 
   257     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeUp, ERemConCoreApiButtonRelease);
 
   254     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );   
   258     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   255     QVERIFY( ! mUserInputHdlr->iVolumeRepeatTimer->IsActive() );
 
   259     QVERIFY( ! mUserInputHdlr->iVolumeRepeatTimer->IsActive() );
 
   256     
   260 
   257     cleanup();        
   261     cleanup();
 
   258 }
 
   262 }
 
   259 
   263 
   260 void TestUserInputHandler::testProcessMediaKeyVolumeDown()
 
   264 void TestUserInputHandler::testProcessMediaKeyVolumeDown()
 
   261 {    
   265 {
 
   262     init();
 
   266     init();
 
   263     
   267 
   264     mUserInputHdlr->iProcessingInputType = EVideoNone;    
   268     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
   265     
   269 
   266     // Issue Play
 
   270     // Issue Play
 
   267     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   271     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonPress);
 
   268     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   272     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiPlay, ERemConCoreApiButtonRelease);
 
   269     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   273     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   270     
   274 
   271     // Volume Down
 
   275     // Volume Down
 
   272     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeDown, ERemConCoreApiButtonPress);
 
   276     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeDown, ERemConCoreApiButtonPress);
 
   273     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );    
   277     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoMediaKeys );
 
   274     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiVolumeDown );   
   278     QVERIFY( mUserInputHdlr->iLastMediaKeyPressed == ERemConCoreApiVolumeDown );
 
   275     QVERIFY( mUserInputHdlr->iVolumeRepeatTimer->IsActive() );
 
   279     QVERIFY( mUserInputHdlr->iVolumeRepeatTimer->IsActive() );
 
   276     QVERIFY( ! mUserInputHdlr->iVolumeRepeatUp );
 
   280     QVERIFY( ! mUserInputHdlr->iVolumeRepeatUp );
 
       
   281 
       
   282     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeDown, ERemConCoreApiButtonRelease);
 
       
   283     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
       
   284     QVERIFY( ! mUserInputHdlr->iVolumeRepeatTimer->IsActive() );
 
       
   285 
       
   286     cleanup();
 
       
   287 }
 
       
   288 
       
   289 void TestUserInputHandler::testProcessMediaKeyWhenLocked()
 
       
   290 {
 
   277     
   291     
   278     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeDown, ERemConCoreApiButtonRelease); 
   292     init();
 
   279     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );   
   293 
   280     QVERIFY( ! mUserInputHdlr->iVolumeRepeatTimer->IsActive() );    
   294     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
       
   295     RProperty::Set( KPSUidAvkonDomain, KAknKeyguardStatus, true );  
       
   296 
       
   297     // media keys should be ignored when key lock is ON
 
       
   298     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeDown, ERemConCoreApiButtonPress);
 
       
   299     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   281     
   300     
   282     cleanup();     
   301     RProperty::Set( KPSUidAvkonDomain, KAknKeyguardStatus, false ); 
   283 }
 
   302 
   284 
   303     cleanup();       
   285 void TestUserInputHandler::testHandleTVOutEventL()
 
   304 }
 
   286 {   
   305 
   287     
   306 void TestUserInputHandler::testProcessMediaKeyWhenInBackground()
 
   288     ///////////////////////////////
 
   307 {
 
   289     // 1. HandleTVOutEventL(true)
 
   308     init();
 
   290     ///////////////////////////////
 
   309 
   291     init();
 
   310     mUserInputHdlr->iProcessingInputType = EVideoNone;
 
   292     
   311     mUserInputHdlr->iForeground = false;
 
   293     mUserInputHdlr->iDisplayTimeOut = 0;
 
   312 
   294     
   313     // media keys should be ignored when not in foreground 
   295     mUserInputHdlr->HandleTVOutEventL(true);
 
   314     mUserInputHdlr->ProcessMediaKey(ERemConCoreApiVolumeDown, ERemConCoreApiButtonPress);
 
   296     
   315     QVERIFY( mUserInputHdlr->iProcessingInputType == EVideoNone );
 
   297     QVERIFY( mUserInputHdlr->iDisplayTimeOut != 0 ); 
   316 
   298     QVERIFY( mUserInputHdlr->iDisplayTimer->IsActive() );
 
   317     cleanup();      
   299         
   318 }
 
   300     cleanup();
 
       
   301     
       
   302     
       
   303     ///////////////////////////////
 
       
   304     // 2. HandleTVOutEventL(false)
 
       
   305     ///////////////////////////////
 
       
   306     init();
 
       
   307     
       
   308     mUserInputHdlr->iDisplayTimeOut = 0;
 
       
   309     
       
   310     mUserInputHdlr->HandleTVOutEventL(false);   
       
   311     QVERIFY( ! mUserInputHdlr->iDisplayTimer->IsActive() );    
       
   312         
       
   313     cleanup();    
       
   314         
       
   315 }
 
       
   316 
       
   317 
       
   318 
       
   319 
   319 
   320 // End of file
 
   320 // End of file
 
   321     
       
   322 
       
   323
FCL/sf/app/videoplayer