59 TestMPXVideoViewWrapper tv; |
57 TestMPXVideoViewWrapper tv; |
60 |
58 |
61 char *pass[3]; |
59 char *pass[3]; |
62 pass[0] = argv[0]; |
60 pass[0] = argv[0]; |
63 pass[1] = "-o"; |
61 pass[1] = "-o"; |
64 pass[2] = "c:\\data\\TestMPXVideoViewWrapper.txt"; |
62 pass[2] = "c:\\data\\testmpxvideoviewwrapper.txt"; |
65 |
63 |
66 int res = QTest::qExec(&tv, 3, pass); |
64 int res = QTest::qExec(&tv, 3, pass); |
67 |
65 |
68 return res; |
66 return res; |
69 } |
67 } |
70 |
|
71 |
68 |
72 // --------------------------------------------------------------------------- |
69 // --------------------------------------------------------------------------- |
73 // init |
70 // init |
74 // --------------------------------------------------------------------------- |
71 // --------------------------------------------------------------------------- |
75 // |
72 // |
76 void TestMPXVideoViewWrapper::init() |
73 void TestMPXVideoViewWrapper::init() |
77 { |
74 { |
78 mBaseVideoView = new HbVideoBasePlaybackView(); |
75 mBaseVideoView = new HbVideoBasePlaybackView(); |
79 TRAPD( err, mVideoViewWrapper = CMPXVideoViewWrapper::NewL( mBaseVideoView ) ); |
76 TRAPD( err, mVideoViewWrapper = CMPXVideoViewWrapper::NewL( mBaseVideoView ) ); |
80 QVERIFY( err == KErrNone ); |
77 QVERIFY( err == KErrNone ); |
81 } |
78 } |
82 |
79 |
83 // --------------------------------------------------------------------------- |
80 // --------------------------------------------------------------------------- |
84 // cleanup |
81 // cleanup |
85 // --------------------------------------------------------------------------- |
82 // --------------------------------------------------------------------------- |
86 // |
83 // |
87 void TestMPXVideoViewWrapper::cleanup() |
84 void TestMPXVideoViewWrapper::cleanup() |
88 { |
85 { |
89 delete mVideoViewWrapper; |
86 if ( mVideoViewWrapper ) |
90 mVideoViewWrapper = NULL; |
87 { |
91 |
88 delete mVideoViewWrapper; |
92 delete mBaseVideoView; |
89 mVideoViewWrapper = NULL; |
93 mBaseVideoView = NULL; |
90 } |
94 } |
91 |
95 |
92 if ( mBaseVideoView ) |
|
93 { |
|
94 delete mBaseVideoView; |
|
95 mBaseVideoView = NULL; |
|
96 } |
|
97 } |
96 |
98 |
97 void TestMPXVideoViewWrapper::testRequestMedia() |
99 void TestMPXVideoViewWrapper::testRequestMedia() |
98 { |
100 { |
99 init(); |
101 init(); |
100 |
102 |
101 TRAPD(err, mVideoViewWrapper->RequestMediaL()); |
103 TRAPD(err, mVideoViewWrapper->RequestMediaL()); |
102 QVERIFY( err == KErrNone ); |
104 QVERIFY( err == KErrNone ); |
103 |
105 |
104 QVERIFY( mVideoViewWrapper->iMediaRequested == true ); |
106 QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaRequested ); |
105 |
107 |
106 cleanup(); |
108 cleanup(); |
107 |
|
108 } |
109 } |
109 |
110 |
110 void TestMPXVideoViewWrapper::testIsLive() |
111 void TestMPXVideoViewWrapper::testIsLive() |
111 { |
112 { |
112 init(); |
113 init(); |
113 |
114 |
114 TRAPD(err, mVideoViewWrapper->RequestMediaL()); |
115 TRAPD(err, mVideoViewWrapper->RequestMediaL()); |
115 QVERIFY( err == KErrNone ); |
116 QVERIFY( err == KErrNone ); |
116 |
117 |
117 mVideoViewWrapper->IsLive(); |
118 mVideoViewWrapper->iFileDetails->mPlaybackMode = EMPXVideoLiveStreaming; |
118 |
119 QVERIFY( mVideoViewWrapper->IsLive() ); |
119 mVideoViewWrapper->iFileDetails->clearFileDetails(); |
120 |
120 |
121 mVideoViewWrapper->iFileDetails->mPlaybackMode = EMPXVideoLocal; |
121 QVERIFY( ! mVideoViewWrapper->IsLive() ); |
122 QVERIFY( ! mVideoViewWrapper->IsLive() ); |
122 |
123 |
123 cleanup(); |
124 cleanup(); |
124 } |
125 } |
125 |
126 |
126 |
|
127 void TestMPXVideoViewWrapper::testIsPlaylist() |
127 void TestMPXVideoViewWrapper::testIsPlaylist() |
128 { |
128 { |
129 init(); |
129 init(); |
130 |
130 |
131 mVideoViewWrapper->IsPlaylist(); |
131 mVideoViewWrapper->iPlaylistView = true; |
132 |
132 QVERIFY( mVideoViewWrapper->IsPlaylist() == true ); |
|
133 |
|
134 mVideoViewWrapper->iPlaylistView = false; |
133 QVERIFY( mVideoViewWrapper->IsPlaylist() == false ); |
135 QVERIFY( mVideoViewWrapper->IsPlaylist() == false ); |
|
136 |
|
137 cleanup(); |
|
138 } |
|
139 |
|
140 void TestMPXVideoViewWrapper::testHandleCommand() |
|
141 { |
|
142 init(); |
|
143 |
|
144 TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() ); |
|
145 QVERIFY( errReqMedia == KErrNone ); |
|
146 |
|
147 // |
|
148 // Test 'Play' command |
|
149 // |
|
150 TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) ); |
|
151 QVERIFY( errHdlCmd == KErrNone ); |
|
152 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay ); |
|
153 |
|
154 // |
|
155 // Test 'Pause' command |
|
156 // |
|
157 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPause ) ); |
|
158 QVERIFY( errHdlCmd == KErrNone ); |
|
159 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPause ); |
|
160 |
|
161 // |
|
162 // Test 'Close' command |
|
163 // |
|
164 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdClose ) ); |
|
165 QVERIFY( errHdlCmd == KErrNone ); |
|
166 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdClose ); |
|
167 |
|
168 // |
|
169 // Test 'Seek Forward' command |
|
170 // |
|
171 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdSeekForward ) ); |
|
172 QVERIFY( errHdlCmd == KErrNone ); |
|
173 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStartVideoSeekingForward ); |
|
174 |
|
175 // |
|
176 // Test 'Seek Backward' command |
|
177 // |
|
178 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdSeekBackward ) ); |
|
179 QVERIFY( errHdlCmd == KErrNone ); |
|
180 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStartVideoSeekingBackward ); |
|
181 |
|
182 // |
|
183 // Test 'End Seek' command |
|
184 // |
|
185 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdEndSeek ) ); |
|
186 QVERIFY( errHdlCmd == KErrNone ); |
|
187 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStopVideoSeeking ); |
|
188 |
|
189 // |
|
190 // Test 'PlayPause' command |
|
191 // |
|
192 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlayPause ) ); |
|
193 QVERIFY( errHdlCmd == KErrNone ); |
|
194 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlayPause ); |
|
195 |
|
196 // |
|
197 // Test 'Stop' command |
|
198 // |
|
199 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdStop ) ); |
|
200 QVERIFY( errHdlCmd == KErrNone ); |
|
201 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStop ); |
|
202 |
|
203 // |
|
204 // Test 'Decrease Volume' command |
|
205 // |
|
206 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdDecreaseVolume ) ); |
|
207 QVERIFY( errHdlCmd == KErrNone ); |
|
208 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleDecreaseVolume ); |
|
209 |
|
210 // |
|
211 // Test 'Increase Volume' command |
|
212 // |
|
213 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdIncreaseVolume ) ); |
|
214 QVERIFY( errHdlCmd == KErrNone ); |
|
215 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleIncreaseVolume ); |
134 |
216 |
135 cleanup(); |
217 // |
136 |
218 // Test 'Natural Aspect Ratio' command |
137 } |
219 // |
138 |
220 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdNaturalAspectRatio ) ); |
139 |
221 QVERIFY( errHdlCmd == KErrNone ); |
140 void TestMPXVideoViewWrapper::testHandleCommand() |
222 QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdNaturalAspectRatio ); |
141 { |
223 |
142 init(); |
224 // |
143 |
225 // Test 'Zoom Aspect Ratio' command |
|
226 // |
|
227 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdZoomAspectRatio ) ); |
|
228 QVERIFY( errHdlCmd == KErrNone ); |
|
229 QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdZoomAspectRatio ); |
|
230 |
|
231 // |
|
232 // Test 'Stretch Aspect Ratio' command |
|
233 // |
|
234 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdStretchAspectRatio ) ); |
|
235 QVERIFY( errHdlCmd == KErrNone ); |
|
236 QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdStretchAspectRatio ); |
|
237 |
|
238 // |
|
239 // Test 'Mute' command |
|
240 // |
|
241 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdMute ) ); |
|
242 QVERIFY( errHdlCmd == KErrNone ); |
|
243 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdMuteVolume ); |
|
244 |
|
245 // |
|
246 // Test 'Un-mute' command |
|
247 // |
|
248 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdUnMute ) ); |
|
249 QVERIFY( errHdlCmd == KErrNone ); |
|
250 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdUnMuteVolume ); |
|
251 |
|
252 // |
|
253 // Test 'Short Press Backward' command |
|
254 // |
|
255 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdShortPressBackward ) ); |
|
256 QVERIFY( errHdlCmd == KErrNone ); |
|
257 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iProperty == EPbPropertyPosition ); |
|
258 |
|
259 // |
|
260 // Test 'Reset Controls' command |
|
261 // |
|
262 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdResetControls ) ); |
|
263 QVERIFY( errHdlCmd == KErrNone ); |
|
264 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdInitView ); |
|
265 |
|
266 // |
|
267 // Test 'Next List Item' command |
|
268 // |
|
269 mVideoViewWrapper->iPlaylistView = true; |
|
270 mVideoViewWrapper->iFileDetails->mMultiItemPlaylist = true; |
|
271 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdNextListItem ) ); |
|
272 QVERIFY( errHdlCmd == KErrNone ); |
|
273 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdNext ); |
|
274 |
|
275 // |
|
276 // Test 'Previous List Item' command |
|
277 // |
|
278 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPreviousListItem ) ); |
|
279 QVERIFY( errHdlCmd == KErrNone ); |
|
280 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPrevious ); |
|
281 |
|
282 // |
|
283 // Test 'End Of Clip' command |
|
284 // |
|
285 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdEndOfClip ) ); |
|
286 QVERIFY( errHdlCmd == KErrNone ); |
|
287 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdEndofClipReached ); |
|
288 |
|
289 // |
|
290 // Test 'Custom Pause' command |
|
291 // |
|
292 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdCustomPause ) ); |
|
293 QVERIFY( errHdlCmd == KErrNone ); |
|
294 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdCustomPause ); |
|
295 |
|
296 // |
|
297 // Test 'Custom Play' command |
|
298 // |
|
299 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdCustomPlay ) ); |
|
300 QVERIFY( errHdlCmd == KErrNone ); |
|
301 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdCustomPlay ); |
|
302 |
|
303 // |
|
304 // Test 'RealOne Bitmap Timeout' command |
|
305 // |
|
306 mVideoViewWrapper->iMediaRequestStatus = MediaDelivered; |
|
307 TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdRealOneBitmapTimeout ) ); |
|
308 QVERIFY( errHdlCmd == KErrNone ); |
|
309 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay ); |
|
310 |
|
311 cleanup(); |
|
312 } |
|
313 |
|
314 void TestMPXVideoViewWrapper::testHandlePluginError() |
|
315 { |
|
316 init(); |
|
317 |
144 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
318 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
145 QVERIFY( errReqMedia == KErrNone ); |
319 QVERIFY( errReqMedia == KErrNone ); |
146 |
320 |
147 TRAPD(errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay )); |
|
148 QVERIFY( errHdlCmd == KErrNone ); |
|
149 |
|
150 int state; |
|
151 TRAPD(errState, state = mVideoViewWrapper->iPlaybackUtility->StateL()); |
|
152 QVERIFY( errState == KErrNone ); |
|
153 |
|
154 QVERIFY( state == EPbStatePlaying ); |
|
155 |
|
156 cleanup(); |
|
157 |
|
158 } |
|
159 |
|
160 |
|
161 |
|
162 void TestMPXVideoViewWrapper::testHandlePluginError() |
|
163 { |
|
164 init(); |
|
165 |
|
166 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
|
167 QVERIFY( errReqMedia == KErrNone ); |
|
168 |
|
169 mVideoViewWrapper->HandlePluginError( KErrNotSupported ); |
321 mVideoViewWrapper->HandlePluginError( KErrNotSupported ); |
170 |
322 |
171 QVERIFY( mVideoViewWrapper->iView->mCurrentError == KErrNotSupported ); |
323 QVERIFY( mVideoViewWrapper->iView->mCurrentError == KErrNotSupported ); |
172 |
324 |
173 cleanup(); |
325 cleanup(); |
174 |
326 } |
175 } |
|
176 |
|
177 |
327 |
178 void TestMPXVideoViewWrapper::testHandlePlaybackMessage() |
328 void TestMPXVideoViewWrapper::testHandlePlaybackMessage() |
179 { |
329 { |
180 init(); |
330 init(); |
181 |
331 |
232 } |
379 } |
233 |
380 |
234 cleanup(); |
381 cleanup(); |
235 } |
382 } |
236 |
383 |
237 |
|
238 void TestMPXVideoViewWrapper::testSetProperty() |
384 void TestMPXVideoViewWrapper::testSetProperty() |
239 { |
385 { |
240 init(); |
386 init(); |
241 |
387 |
|
388 TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL()) ; |
|
389 QVERIFY( errReqMedia == KErrNone ); |
|
390 |
|
391 TMPXPlaybackProperty property = EPbPropertyMute; |
|
392 TInt propertyValue = 1; |
|
393 |
|
394 TRAPD( errSetProp, mVideoViewWrapper->SetPropertyL( property, propertyValue ) ); |
|
395 QVERIFY( errSetProp == KErrNone ); |
|
396 |
|
397 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iProperty == property ); |
|
398 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iPropertyValue == propertyValue ); |
|
399 |
|
400 cleanup(); |
|
401 } |
|
402 |
|
403 void TestMPXVideoViewWrapper::testHandleProperty() |
|
404 { |
|
405 init(); |
|
406 |
242 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
407 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
243 QVERIFY( errReqMedia == KErrNone ); |
408 QVERIFY( errReqMedia == KErrNone ); |
244 |
409 |
245 TRAPD(errSetProp, mVideoViewWrapper->SetPropertyL( EPbPropertyMute, 1 ) ); // 0=>noraml 1=>muted |
410 // |
246 QVERIFY( errSetProp == KErrNone ); |
411 // Duration |
247 |
412 // |
248 QVERIFY( ! mVideoViewWrapper->iFileDetails->mAudioEnabled ); |
413 int value = 5000; |
249 |
414 TRAPD(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyDuration, value, KErrNone ) ); |
250 cleanup(); |
|
251 } |
|
252 |
|
253 |
|
254 void TestMPXVideoViewWrapper::testHandleProperty() |
|
255 { |
|
256 init(); |
|
257 |
|
258 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
|
259 QVERIFY( errReqMedia == KErrNone ); |
|
260 |
|
261 TRAPD(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyDuration, 5000, KErrNone )); |
|
262 QVERIFY( errHdlProp == KErrNone ); |
415 QVERIFY( errHdlProp == KErrNone ); |
263 |
416 |
264 QVERIFY( mVideoViewWrapper->iFileDetails->mDuration == 5000 ); |
417 QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetDuration ); |
265 |
418 QVERIFY( mVideoViewWrapper->iControlsController->mValue == value ); |
266 cleanup(); |
419 |
267 } |
420 // |
268 |
421 // Position |
|
422 // |
|
423 value = 500; |
|
424 |
|
425 TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyPosition, value, KErrNone ) ); |
|
426 QVERIFY( errHdlProp == KErrNone ); |
|
427 |
|
428 QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetPosition ); |
|
429 QVERIFY( mVideoViewWrapper->iControlsController->mValue == value ); |
|
430 |
|
431 // |
|
432 // Volume |
|
433 // |
|
434 value = 10; |
|
435 |
|
436 TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyVolume, value, KErrNone ) ); |
|
437 QVERIFY( errHdlProp == KErrNone ); |
|
438 |
|
439 QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetVolume ); |
|
440 QVERIFY( mVideoViewWrapper->iControlsController->mValue == value ); |
|
441 |
|
442 // |
|
443 // Mute |
|
444 // |
|
445 value = 1; |
|
446 |
|
447 TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyMute, value, KErrNone ) ); |
|
448 QVERIFY( errHdlProp == KErrNone ); |
|
449 |
|
450 QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetVolume ); |
|
451 QVERIFY( mVideoViewWrapper->iControlsController->mValue == 0 ); |
|
452 |
|
453 cleanup(); |
|
454 } |
269 |
455 |
270 void TestMPXVideoViewWrapper::testRetrieveFileNameAndMode() |
456 void TestMPXVideoViewWrapper::testRetrieveFileNameAndMode() |
271 { |
457 { |
272 init(); |
458 init(); |
273 |
459 |
274 mVideoViewWrapper->iFileDetails->clearFileDetails(); |
460 mVideoViewWrapper->iFileDetails->clearFileDetails(); |
275 |
461 |
276 CMPXCommand* cmd = NULL; |
462 CMPXCommand* cmd = NULL; |
277 |
463 |
278 TRAP_IGNORE( cmd = CMPXCommand::NewL() ); |
464 TRAP_IGNORE( cmd = CMPXCommand::NewL() ); |
279 |
465 |
280 TRAPD(errRetFileName, mVideoViewWrapper->RetrieveFileNameAndModeL( cmd ) ); |
466 if ( cmd ) |
281 QVERIFY( errRetFileName == KErrNone ); |
467 { |
282 |
468 TRAPD(errRetFileName, mVideoViewWrapper->RetrieveFileNameAndModeL( cmd ) ); |
283 int state; |
469 QVERIFY( errRetFileName == KErrNone ); |
284 TRAPD(errState, state = mVideoViewWrapper->iPlaybackUtility->StateL()); |
470 |
285 QVERIFY( errState == KErrNone ); |
471 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdInitView ); |
286 |
472 |
287 QVERIFY( state == EPbStateInitialised ); |
473 QCOMPARE( mVideoViewWrapper->iFileDetails->mClipName, QString("testClip.3gp")); |
288 |
474 |
289 QCOMPARE( mVideoViewWrapper->iFileDetails->mClipName, QString("testClip.3gp")); |
475 delete cmd; |
290 |
476 cmd = NULL; |
291 delete cmd; |
477 } |
292 cmd = NULL; |
478 |
293 |
479 cleanup(); |
294 cleanup(); |
480 } |
295 } |
|
296 |
|
297 |
481 |
298 void TestMPXVideoViewWrapper::testActivateClosePlayerActiveObject() |
482 void TestMPXVideoViewWrapper::testActivateClosePlayerActiveObject() |
299 { |
483 { |
300 init(); |
484 init(); |
301 |
485 |
302 mVideoViewWrapper->ActivateClosePlayerActiveObject(); |
486 mVideoViewWrapper->ActivateClosePlayerActiveObject(); |
303 |
487 |
304 QVERIFY( mVideoViewWrapper->iCloseAO->IsActive() ); |
488 QVERIFY( mVideoViewWrapper->iCloseAO->IsActive() ); |
305 |
489 |
306 cleanup(); |
490 cleanup(); |
307 } |
491 } |
308 |
|
309 |
492 |
310 void TestMPXVideoViewWrapper::testDoClosePlayer() |
493 void TestMPXVideoViewWrapper::testDoClosePlayer() |
311 { |
494 { |
312 init(); |
495 init(); |
313 |
496 |
314 TRAPD(err, mVideoViewWrapper->DoClosePlayerL()); |
497 TRAPD(err, mVideoViewWrapper->DoClosePlayerL()); |
315 QVERIFY( err == KErrNone ); |
498 QVERIFY( err == KErrNone ); |
316 |
499 |
317 QVERIFY( ! mVideoViewWrapper->iView->mViewActive ); |
500 QVERIFY( ! mVideoViewWrapper->iView->mViewActive ); |
318 |
501 |
319 cleanup(); |
502 cleanup(); |
320 } |
503 } |
321 |
504 |
322 |
505 void TestMPXVideoViewWrapper::testSetAspectRatio() |
323 void TestMPXVideoViewWrapper::testIssuePlayCommand() |
506 { |
324 { |
507 init(); |
325 init(); |
508 TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() ); |
|
509 QVERIFY( errReqMedia == KErrNone ); |
|
510 |
|
511 TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdStretchAspectRatio ) ); |
|
512 QVERIFY( errHdlCmd == KErrNone ); |
|
513 |
|
514 QVERIFY( mVideoViewWrapper->iDisplayHandler->iAspectRatio == EMMFStretch ); |
|
515 |
|
516 cleanup(); |
|
517 } |
|
518 |
|
519 void TestMPXVideoViewWrapper::testIsAppInFront() |
|
520 { |
|
521 init(); |
|
522 |
326 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
523 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
327 QVERIFY( errReqMedia == KErrNone ); |
524 QVERIFY( errReqMedia == KErrNone ); |
328 |
525 |
329 TRAPD(errIssuePlay, mVideoViewWrapper->IssuePlayCommandL()); |
|
330 QVERIFY( errIssuePlay == KErrNone ); |
|
331 |
|
332 |
|
333 int state; |
|
334 TRAPD(errState, state = mVideoViewWrapper->iPlaybackUtility->StateL()); |
|
335 QVERIFY( errState == KErrNone ); |
|
336 |
|
337 QVERIFY( state == EPbStatePlaying ); |
|
338 |
|
339 cleanup(); |
|
340 } |
|
341 |
|
342 |
|
343 void TestMPXVideoViewWrapper::testSetAspectRatio() |
|
344 { |
|
345 init(); |
|
346 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
|
347 QVERIFY( errReqMedia == KErrNone ); |
|
348 |
|
349 TRAPD(errHdlCmd, mVideoViewWrapper->HandleCommandL(EMPXPbvCmdStretchAspectRatio)); |
|
350 QVERIFY( errHdlCmd == KErrNone ); |
|
351 |
|
352 QVERIFY( mVideoViewWrapper->iDisplayHandler->iCurrentIndexForAspectRatio == 1 ); |
|
353 |
|
354 cleanup(); |
|
355 } |
|
356 |
|
357 |
|
358 void TestMPXVideoViewWrapper::testIsAppInFront() |
|
359 { |
|
360 init(); |
|
361 |
|
362 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
|
363 QVERIFY( errReqMedia == KErrNone ); |
|
364 |
|
365 bool front = false; |
526 bool front = false; |
366 TRAPD(errIsAppInFrnt, front = mVideoViewWrapper->IsAppInFrontL()); |
527 TRAPD( errIsAppInFrnt, front = mVideoViewWrapper->IsAppInFrontL() ); |
367 |
528 |
368 QVERIFY( errIsAppInFrnt == KErrNone ); |
529 QVERIFY( errIsAppInFrnt == KErrNone ); |
369 |
530 |
370 cleanup(); |
531 cleanup(); |
371 } |
532 } |
372 |
|
373 |
533 |
374 void TestMPXVideoViewWrapper::testClosePlaybackView() |
534 void TestMPXVideoViewWrapper::testClosePlaybackView() |
375 { |
535 { |
376 init(); |
536 init(); |
377 |
537 |
378 TRAPD(err, mVideoViewWrapper->ClosePlaybackViewL()); |
538 TRAPD(err, mVideoViewWrapper->ClosePlaybackViewL()); |
379 QVERIFY( err == KErrNone ); |
539 QVERIFY( err == KErrNone ); |
380 |
540 |
381 QVERIFY( ! mVideoViewWrapper->iView->mViewActive ); |
541 QVERIFY( ! mVideoViewWrapper->iView->mViewActive ); |
382 |
542 |
383 cleanup(); |
543 cleanup(); |
384 } |
544 } |
385 |
|
386 |
545 |
387 void TestMPXVideoViewWrapper::testHandleVolumeCmd() |
546 void TestMPXVideoViewWrapper::testHandleVolumeCmd() |
388 { |
547 { |
389 init(); |
548 init(); |
390 |
549 |
391 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
550 TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() ); |
392 QVERIFY( errReqMedia == KErrNone ); |
551 QVERIFY( errReqMedia == KErrNone ); |
393 |
552 |
394 TRAPD(errIssuePlay, mVideoViewWrapper->IssuePlayCommandL()); |
553 TRAPD( errIssuePlay, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) ); |
|
554 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay ); |
395 QVERIFY( errIssuePlay == KErrNone ); |
555 QVERIFY( errIssuePlay == KErrNone ); |
396 |
556 |
397 TRAPD(errHdlCmd, mVideoViewWrapper->HandleCommandL(EMPXPbvCmdDecreaseVolume)); |
557 TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdDecreaseVolume ) ); |
|
558 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleDecreaseVolume ); |
398 QVERIFY( errHdlCmd == KErrNone ); |
559 QVERIFY( errHdlCmd == KErrNone ); |
399 |
560 |
400 QVERIFY( mVideoViewWrapper->iFileDetails->mAudioEnabled ); |
561 QVERIFY( mVideoViewWrapper->iFileDetails->mAudioEnabled ); |
401 |
562 |
402 cleanup(); |
563 cleanup(); |
403 } |
564 } |
404 |
|
405 |
565 |
406 void TestMPXVideoViewWrapper::testHandleShortPressBackward() |
566 void TestMPXVideoViewWrapper::testHandleShortPressBackward() |
407 { |
567 { |
408 init(); |
568 init(); |
409 |
569 |
410 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
570 TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() ); |
411 QVERIFY( errReqMedia == KErrNone ); |
571 QVERIFY( errReqMedia == KErrNone ); |
412 |
572 |
413 TRAPD(errIssuePlay, mVideoViewWrapper->IssuePlayCommandL()); |
573 TRAPD( errIssuePlay, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) ); |
|
574 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay ); |
414 QVERIFY( errIssuePlay == KErrNone ); |
575 QVERIFY( errIssuePlay == KErrNone ); |
415 |
576 |
416 TRAPD(errHdlCmd, mVideoViewWrapper->HandleCommandL(EMPXPbvCmdShortPressBackward)); |
577 TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdShortPressBackward ) ); |
|
578 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iProperty == EPbPropertyPosition ); |
|
579 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iPropertyValue == 0 ); |
|
580 |
417 QVERIFY( errHdlCmd == KErrNone ); |
581 QVERIFY( errHdlCmd == KErrNone ); |
418 |
582 |
419 cleanup(); |
583 cleanup(); |
420 } |
584 } |
421 |
|
422 |
585 |
423 void TestMPXVideoViewWrapper::testIssueVideoAppForegroundCmd() |
586 void TestMPXVideoViewWrapper::testIssueVideoAppForegroundCmd() |
424 { |
587 { |
425 init(); |
588 init(); |
426 |
589 |
427 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
590 TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() ); |
428 QVERIFY( errReqMedia == KErrNone ); |
591 QVERIFY( errReqMedia == KErrNone ); |
429 |
592 |
430 TRAPD(errIssuePlay, mVideoViewWrapper->IssuePlayCommandL()); |
593 TRAPD( errIssuePlay, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) ); |
|
594 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay ); |
|
595 |
431 QVERIFY( errIssuePlay == KErrNone ); |
596 QVERIFY( errIssuePlay == KErrNone ); |
432 |
597 |
433 TRAPD(errIssueVidAppFGCmd, mVideoViewWrapper->IssueVideoAppForegroundCmdL( ETrue )); |
598 // |
|
599 // test foreground |
|
600 // |
|
601 TRAPD( errIssueVidAppFGCmd, mVideoViewWrapper->IssueVideoAppForegroundCmdL( ETrue ) ); |
|
602 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleForeground ); |
434 QVERIFY( errIssueVidAppFGCmd == KErrNone ); |
603 QVERIFY( errIssueVidAppFGCmd == KErrNone ); |
435 |
604 |
436 cleanup(); |
605 // |
437 } |
606 // test background |
438 |
607 // |
|
608 TRAP( errIssueVidAppFGCmd, mVideoViewWrapper->IssueVideoAppForegroundCmdL( EFalse ) ); |
|
609 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleBackground ); |
|
610 QVERIFY( errIssueVidAppFGCmd == KErrNone ); |
|
611 |
|
612 cleanup(); |
|
613 } |
439 |
614 |
440 void TestMPXVideoViewWrapper::testCreateControls() |
615 void TestMPXVideoViewWrapper::testCreateControls() |
441 { |
616 { |
442 init(); |
617 init(); |
443 |
618 |
444 TRAPD(err, mVideoViewWrapper->CreateControlsL()); |
619 TRAPD(err, mVideoViewWrapper->CreateControlsL()); |
445 QVERIFY( err == KErrNone ); |
620 QVERIFY( err == KErrNone ); |
446 |
621 |
447 QVERIFY( mVideoViewWrapper->iControlsController ); |
622 QVERIFY( mVideoViewWrapper->iControlsController ); |
448 |
623 |
449 cleanup(); |
624 cleanup(); |
450 } |
625 } |
451 |
|
452 |
626 |
453 void TestMPXVideoViewWrapper::testIsMultiItemPlaylist() |
627 void TestMPXVideoViewWrapper::testIsMultiItemPlaylist() |
454 { |
628 { |
455 init(); |
629 init(); |
456 |
630 |
457 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
631 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
458 QVERIFY( errReqMedia == KErrNone ); |
632 QVERIFY( errReqMedia == KErrNone ); |
459 |
633 |
460 QVERIFY( ! mVideoViewWrapper->IsMultiItemPlaylist() ); |
634 QVERIFY( ! mVideoViewWrapper->IsMultiItemPlaylist() ); |
461 |
635 |
462 cleanup(); |
636 cleanup(); |
463 } |
637 } |
464 |
|
465 |
638 |
466 void TestMPXVideoViewWrapper::testUpdateVideoRect() |
639 void TestMPXVideoViewWrapper::testUpdateVideoRect() |
467 { |
640 { |
468 init(); |
641 init(); |
469 |
642 |
470 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
643 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
471 QVERIFY( errReqMedia == KErrNone ); |
644 QVERIFY( errReqMedia == KErrNone ); |
472 |
645 |
473 mVideoViewWrapper->UpdateVideoRect(0,0,50,50,false); |
646 TRect rect( 0, 0, 50, 50 ); |
474 |
647 |
475 float brY = 50; |
648 mVideoViewWrapper->UpdateVideoRect( |
476 |
649 rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY, false ); |
477 QCOMPARE(mVideoViewWrapper->iDisplayHandler->iBrYDiff, brY); |
650 |
478 |
651 QVERIFY( rect == mVideoViewWrapper->iDisplayHandler->iRect ); |
|
652 |
479 cleanup(); |
653 cleanup(); |
480 } |
654 } |
481 |
655 |
482 void TestMPXVideoViewWrapper::testUpdateVideoRectDone() |
656 void TestMPXVideoViewWrapper::testUpdateVideoRectDone() |
483 { |
657 { |
484 init(); |
658 init(); |
485 |
659 |
486 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
660 TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL()); |
487 QVERIFY( errReqMedia == KErrNone ); |
661 QVERIFY( errReqMedia == KErrNone ); |
488 |
662 |
489 mVideoViewWrapper->UpdateVideoRectDone(); |
663 mVideoViewWrapper->UpdateVideoRectDone(); |
490 |
664 |
491 cleanup(); |
665 cleanup(); |
492 } |
666 } |
493 |
|
494 |
|
495 |
667 |
496 void TestMPXVideoViewWrapper::testHandleBufferingState() |
668 void TestMPXVideoViewWrapper::testHandleBufferingState() |
497 { |
669 { |
498 init(); |
670 init(); |
499 |
671 |
500 TRAPD(err, mVideoViewWrapper->HandleBufferingStateL()); |
672 TRAPD(err, mVideoViewWrapper->HandleBufferingStateL()); |
501 QVERIFY( err == KErrNone ); |
673 QVERIFY( err == KErrNone ); |
502 |
674 |
503 cleanup(); |
675 cleanup(); |
504 } |
676 } |
505 |
|
506 |
677 |
507 void TestMPXVideoViewWrapper::testHandleVideoPlaybackMessage() |
678 void TestMPXVideoViewWrapper::testHandleVideoPlaybackMessage() |
508 { |
679 { |
509 init(); |
680 init(); |
510 |
681 |
561 cmd = NULL; |
716 cmd = NULL; |
562 |
717 |
563 cleanup(); |
718 cleanup(); |
564 } |
719 } |
565 |
720 |
566 |
|
567 void TestMPXVideoViewWrapper::testHandleMedia() |
721 void TestMPXVideoViewWrapper::testHandleMedia() |
568 { |
722 { |
569 init(); |
723 init(); |
570 |
724 |
571 CMPXMedia* media = NULL; |
725 CMPXMedia* media = NULL; |
572 |
726 |
|
727 // |
|
728 // Error case |
|
729 // |
573 TRAP_IGNORE( |
730 TRAP_IGNORE( |
574 RArray<TInt> suppIds; |
731 RArray<TInt> suppIds; |
575 CleanupClosePushL( suppIds ); |
732 CleanupClosePushL( suppIds ); |
576 suppIds.AppendL( KMPXMediaIdGeneral ); |
733 suppIds.AppendL( KMPXMediaIdGeneral ); |
577 suppIds.AppendL( KMPXMediaIdVideo ); |
734 suppIds.AppendL( KMPXMediaIdVideo ); |
578 |
735 |
579 media = CMPXMedia::NewL( suppIds.Array() ); |
736 media = CMPXMedia::NewL( suppIds.Array() ); |
580 CleanupStack::PopAndDestroy( &suppIds ); |
737 CleanupStack::PopAndDestroy( &suppIds ); |
581 |
738 |
582 media->SetTObjectValueL<TInt>( TMPXAttribute( KMPXMediaVideoError ), |
739 media->SetTObjectValueL<TInt>( TMPXAttribute( KMPXMediaVideoError ), KErrCancel ); |
583 KErrCancel ); |
|
584 ); |
740 ); |
585 |
741 |
586 TRAPD(err, mVideoViewWrapper->HandleMediaL( *media, KErrNone ) ); |
742 TRAPD( err, mVideoViewWrapper->HandleMediaL( *media, KErrNone ) ); |
587 QVERIFY( err == KErrNone ); |
743 QVERIFY( err == KErrNone ); |
588 |
744 |
589 QCOMPARE( mVideoViewWrapper->iView->mCurrentError, KErrCancel ); |
745 QCOMPARE( mVideoViewWrapper->iView->mCurrentError, KErrCancel ); |
|
746 QVERIFY( ! mVideoViewWrapper->iControlsController->mFileDetailsAdded ); |
|
747 QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaNotRequested ); |
590 |
748 |
591 if ( media ) |
749 if ( media ) |
592 { |
750 { |
593 delete media; |
751 delete media; |
594 media = NULL; |
752 media = NULL; |
595 } |
753 } |
596 |
754 |
597 |
755 // |
598 cleanup(); |
756 // working case - RN logo is not visible |
599 } |
757 // |
600 |
758 TRAP_IGNORE( |
|
759 RArray<TInt> suppIds; |
|
760 CleanupClosePushL( suppIds ); |
|
761 suppIds.AppendL( KMPXMediaIdGeneral ); |
|
762 suppIds.AppendL( KMPXMediaIdVideo ); |
|
763 |
|
764 media = CMPXMedia::NewL( suppIds.Array() ); |
|
765 CleanupStack::PopAndDestroy( &suppIds ); |
|
766 ); |
|
767 |
|
768 mVideoViewWrapper->iView->mCurrentError = KErrNone; |
|
769 mVideoViewWrapper->iFileDetails->mVideoEnabled = true; |
|
770 mVideoViewWrapper->iDisplayHandler->SetAspectRatioL( EPbCmdNaturalAspectRatio ); |
|
771 mVideoViewWrapper->iControlsController->mRNLogoVisible = false; |
|
772 |
|
773 TRAP(err, mVideoViewWrapper->HandleMediaL( *media, KErrNone ) ); |
|
774 |
|
775 QVERIFY( err == KErrNone ); |
|
776 QCOMPARE( mVideoViewWrapper->iView->mCurrentError, KErrNone ); |
|
777 QVERIFY( mVideoViewWrapper->iControlsController->mFileDetailsAdded ); |
|
778 QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetAspectRatio ); |
|
779 QVERIFY( mVideoViewWrapper->iControlsController->mValue == EMMFNatural ); |
|
780 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay ); |
|
781 QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaDelivered ); |
|
782 |
|
783 if ( media ) |
|
784 { |
|
785 delete media; |
|
786 media = NULL; |
|
787 } |
|
788 |
|
789 // |
|
790 // working case - RN logo is visible |
|
791 // |
|
792 TRAP_IGNORE( |
|
793 RArray<TInt> suppIds; |
|
794 CleanupClosePushL( suppIds ); |
|
795 suppIds.AppendL( KMPXMediaIdGeneral ); |
|
796 suppIds.AppendL( KMPXMediaIdVideo ); |
|
797 |
|
798 media = CMPXMedia::NewL( suppIds.Array() ); |
|
799 CleanupStack::PopAndDestroy( &suppIds ); |
|
800 ); |
|
801 |
|
802 mVideoViewWrapper->iFileDetails->mVideoEnabled = false; |
|
803 mVideoViewWrapper->iPlaybackUtility->iCommand = EPbCmdPause; |
|
804 mVideoViewWrapper->iControlsController->mFileDetailsAdded = false; |
|
805 mVideoViewWrapper->iDisplayHandler->SetAspectRatioL( EPbCmdZoomAspectRatio ); |
|
806 mVideoViewWrapper->iControlsController->mRNLogoVisible = true; |
|
807 |
|
808 TRAP(err, mVideoViewWrapper->HandleMediaL( *media, KErrNone ) ); |
|
809 |
|
810 QVERIFY( err == KErrNone ); |
|
811 QVERIFY( ! mVideoViewWrapper->iControlsController->mFileDetailsAdded ); |
|
812 QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EMPXControlCmdSetAspectRatio ); |
|
813 QVERIFY( mVideoViewWrapper->iControlsController->mValue == EMMFNatural ); |
|
814 QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPause ); |
|
815 QCOMPARE( mVideoViewWrapper->iView->mCurrentError, KErrNone ); |
|
816 QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaDelivered ); |
|
817 |
|
818 if ( media ) |
|
819 { |
|
820 delete media; |
|
821 media = NULL; |
|
822 } |
|
823 |
|
824 cleanup(); |
|
825 } |
601 |
826 |
602 // End of file |
827 // End of file |
603 |
|
604 |
|
605 |
|