|
1 /* |
|
2 * Copyright (c) 2007 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: STIF testing for MPX Collection Playlist |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <e32svr.h> |
|
21 #include <badesca.h> |
|
22 #include <StifParser.h> |
|
23 #include <Stiftestinterface.h> |
|
24 |
|
25 #include <mpxcollectionplaylist.h> |
|
26 #include <mpxcollectionpath.h> |
|
27 #include <mpxattribute.h> |
|
28 #include "mpxcollectionplaylisttest.h" |
|
29 |
|
30 #include "mpxcollectionobserver.h"//new added |
|
31 #include "mpxcollectionutility.h"//new |
|
32 #include "mpxcollectionplaylistobserver.h" |
|
33 #include "mpxcollectionopenutility.h" |
|
34 #include "mpxmediageneraldefs.h" |
|
35 // ======== MEMBER FUNCTIONS ======== |
|
36 |
|
37 // --------------------------------------------------------------------------- |
|
38 // CMPXCollectionPlaylistTest::Delete |
|
39 // Delete here all resources allocated and opened from test methods. |
|
40 // Called from destructor. |
|
41 // --------------------------------------------------------------------------- |
|
42 // |
|
43 void CMPXCollectionPlaylistTest::Delete() |
|
44 { |
|
45 if ( iCollectionPlaylist ) |
|
46 { |
|
47 delete iCollectionPlaylist; |
|
48 } |
|
49 |
|
50 if ( iCollectionPath ) |
|
51 { |
|
52 iCollectionPath->Reset(); |
|
53 delete iCollectionPath; |
|
54 } |
|
55 iExpectedEvents.Close(); |
|
56 } |
|
57 |
|
58 |
|
59 // ----------------------------------------------------------------------------- |
|
60 // CMPXCollectionPlaylistTest::AddExpectedEvent |
|
61 // Add an event to the expected event list |
|
62 // ----------------------------------------------------------------------------- |
|
63 |
|
64 void CMPXCollectionPlaylistTest::AddExpectedEvent( TExpectedEvents aEvent ) |
|
65 { |
|
66 iLog->Log(_L("CMPXCollectionPlaylistTest::AddExpectedEvent: %d"), aEvent); |
|
67 iExpectedEvents.Append(aEvent); |
|
68 } |
|
69 |
|
70 // ----------------------------------------------------------------------------- |
|
71 // CMPXCollectionPlaylistTest::RemoveExpectedEvent |
|
72 // Remove the event from the expected event list |
|
73 // Returns: ETrue: Event found. |
|
74 // EFalse: Event not found. |
|
75 // ----------------------------------------------------------------------------- |
|
76 TBool CMPXCollectionPlaylistTest::RemoveExpectedEvent( TExpectedEvents aEvent ) |
|
77 { |
|
78 iLog->Log(_L("CMPXCollectionPlaylistTest::RemoveExpectedEvent: %d"), aEvent); |
|
79 TBool match = EFalse; |
|
80 TInt index = iExpectedEvents.Find(aEvent); |
|
81 if ( index != KErrNotFound ) |
|
82 { |
|
83 iExpectedEvents.Remove(index); |
|
84 match = ETrue; |
|
85 } |
|
86 return match; |
|
87 } |
|
88 |
|
89 // ----------------------------------------------------------------------------- |
|
90 // CMPXCollectionPlaylistTest::BuildCollectionPath |
|
91 // Build MPX Collection Path |
|
92 // ----------------------------------------------------------------------------- |
|
93 void CMPXCollectionPlaylistTest::BuildCollectionPathL() |
|
94 { |
|
95 iLog->Log(_L("CMPXCollectionPlaylistTest::BuildCollectionPath")); |
|
96 |
|
97 const TMPXItemId KMPXPathLevel1 = 33331; |
|
98 const TMPXItemId KMPXPathLevel2 = 33332; |
|
99 const TMPXItemId KMPXPathLevel3 = 33333; |
|
100 const TMPXItemId KMPXPathItem1 = 44441; |
|
101 const TMPXItemId KMPXPathItem2 = 44442; |
|
102 const TMPXItemId KMPXPathItem3 = 44443; |
|
103 const TMPXItemId KMPXPathItem4 = 44444; |
|
104 const TMPXItemId KMPXPathItem5 = 44445; |
|
105 RArray<TMPXItemId> itemIdArray; |
|
106 |
|
107 // Start from scratch |
|
108 if ( iCollectionPath ) |
|
109 { |
|
110 iCollectionPath->Reset(); |
|
111 delete iCollectionPath; |
|
112 } |
|
113 // build collection path |
|
114 iCollectionPath = CMPXCollectionPath::NewL(); |
|
115 iCollectionPath->AppendL(KMPXPathLevel1); |
|
116 iCollectionPath->AppendL(KMPXPathLevel2); |
|
117 iCollectionPath->AppendL(KMPXPathLevel3); |
|
118 itemIdArray.Append(KMPXPathItem1); |
|
119 itemIdArray.Append(KMPXPathItem2); |
|
120 itemIdArray.Append(KMPXPathItem3); |
|
121 itemIdArray.Append(KMPXPathItem4); |
|
122 itemIdArray.Append(KMPXPathItem5); |
|
123 iCollectionPath->AppendL(itemIdArray.Array()); |
|
124 |
|
125 itemIdArray.Close(); |
|
126 } |
|
127 |
|
128 // --------------------------------------------------------------------------- |
|
129 // CMPXCollectionPlaylistTest::RunMethodL |
|
130 // Run specified method. Contains also table of test mothods and their names. |
|
131 // --------------------------------------------------------------------------- |
|
132 // |
|
133 TInt CMPXCollectionPlaylistTest::RunMethodL( CStifItemParser& aItem ) |
|
134 { |
|
135 |
|
136 static TStifFunctionInfo const KFunctions[] = |
|
137 { |
|
138 // Copy this line for every implemented function. |
|
139 // First string is the function name used in TestScripter script file. |
|
140 // Second is the actual implementation member function. |
|
141 ENTRY( "Example", CMPXCollectionPlaylistTest::ExampleL ), |
|
142 //ADD NEW ENTRY HERE |
|
143 ENTRY( "CreateUtilityNewPlaylist", CMPXCollectionPlaylistTest::CreateUtilityNewPlaylist ), |
|
144 ENTRY( "CreateUtilityPlaylistExist", CMPXCollectionPlaylistTest::CreateUtilityPlaylistExist ), |
|
145 ENTRY( "CreateUtilityCollectionPath", CMPXCollectionPlaylistTest::CreateUtilityCollectionPath ), |
|
146 ENTRY( "CreateUtilityCollectionStream", CMPXCollectionPlaylistTest::CreateUtilityCollectionStream ), |
|
147 ENTRY( "CopyContentL", CMPXCollectionPlaylistTest::CopyContentL ), |
|
148 ENTRY( "Next", CMPXCollectionPlaylistTest::Next ), |
|
149 ENTRY( "Previous", CMPXCollectionPlaylistTest::Previous ), |
|
150 ENTRY( "SetToFirst", CMPXCollectionPlaylistTest::SetToFirst ), |
|
151 ENTRY( "SetToLast", CMPXCollectionPlaylistTest::SetToLast ), |
|
152 ENTRY( "SetToIndex", CMPXCollectionPlaylistTest::SetToIndex ), |
|
153 ENTRY( "Count", CMPXCollectionPlaylistTest::Count ), |
|
154 ENTRY( "Levels", CMPXCollectionPlaylistTest::Levels ), |
|
155 ENTRY( "Index", CMPXCollectionPlaylistTest::Index ), |
|
156 ENTRY( "Remote", CMPXCollectionPlaylistTest::Remote ), |
|
157 ENTRY( "RepeatMode", CMPXCollectionPlaylistTest::RepeatMode ), |
|
158 ENTRY( "Shuffle", CMPXCollectionPlaylistTest::Shuffle ), |
|
159 ENTRY( "Path", CMPXCollectionPlaylistTest::Path ), |
|
160 ENTRY( "MediaL", CMPXCollectionPlaylistTest::MediaL ), |
|
161 ENTRY( "SetRepeatMode", CMPXCollectionPlaylistTest::SetRepeatMode ), |
|
162 ENTRY( "SetRepeatEnabled", CMPXCollectionPlaylistTest::SetRepeatEnabled ), |
|
163 ENTRY( "SetShuffleL", CMPXCollectionPlaylistTest::SetShuffleL ), |
|
164 ENTRY( "SetShuffleEnabledL", CMPXCollectionPlaylistTest::SetShuffleEnabledL ), |
|
165 ENTRY( "StreamingL", CMPXCollectionPlaylistTest::StreamingL ), |
|
166 ENTRY( "SetObserver", CMPXCollectionPlaylistTest::SetObserver ), |
|
167 ENTRY( "EmbeddedPlaylist", CMPXCollectionPlaylistTest::EmbeddedPlaylist ), |
|
168 ENTRY( "SetEmbeddedPlaylist", CMPXCollectionPlaylistTest::SetEmbeddedPlaylist ), |
|
169 ENTRY( "SetL", CMPXCollectionPlaylistTest::SetL ), |
|
170 ENTRY( "CancelRequest", CMPXCollectionPlaylistTest::CancelRequest ), |
|
171 ENTRY( "Invalidate", CMPXCollectionPlaylistTest::Invalidate ), |
|
172 ENTRY("NextIndex", CMPXCollectionPlaylistTest::NextIndex ), |
|
173 ENTRY("PathIndex",CMPXCollectionPlaylistTest::PathIndex ), |
|
174 //add function |
|
175 ENTRY("CMPXCollectionPlaylistDestructor",CMPXCollectionPlaylistTest::CMPXCollectionPlaylistDestructor ),//Pass debug added 7,10,2008 |
|
176 ENTRY("CMPXCollectionOpenUtilityCreate",CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityCreate ), //Pass debug added 7,10,2008 |
|
177 ENTRY( "CMPXCollectionOpenUtilityStartL", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartL ),//Pass added 7,10,2008 |
|
178 ENTRY( "CMPXCollectionOpenUtilityStop", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStop ),//Pass debug added 7,10,2008 |
|
179 ENTRY( "CMPXCollectionOpenUtilityStartUsingPath", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartUsingPath ),//Pass added 7,10,2008 |
|
180 ENTRY( "CMPXCollectionOpenUtilitySetDelay", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDelay ),//Pass debug added 7,10,2008 |
|
181 ENTRY( "CMPXCollectionOpenUtilitySetDirection", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDirection ),//Pass debug added 7,10,2008 |
|
182 ENTRY( "NewLMMPXCollectionUtility", CMPXCollectionPlaylistTest::NewLMMPXCollectionUtility ),//Pass added by 7,10,2008 |
|
183 ENTRY( "CMPXCollectionOpenUtilityPathL", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityPathL ),//Pass debug added 7,10,2008 |
|
184 }; |
|
185 |
|
186 const TInt count = sizeof( KFunctions ) / |
|
187 sizeof( TStifFunctionInfo ); |
|
188 |
|
189 return RunInternalL( KFunctions, count, aItem ); |
|
190 |
|
191 } |
|
192 |
|
193 // --------------------------------------------------------------------------- |
|
194 // CMPXCollectionPlaylistTest::HandleCollectionMediaL |
|
195 // --------------------------------------------------------------------------- |
|
196 // |
|
197 void CMPXCollectionPlaylistTest::HandleCollectionMediaL( const CMPXMedia& /*aMedia*/, TInt aError ) |
|
198 { |
|
199 iLog->Log(_L("CMPXCollectionPlaylistTest::HandleCollectionMediaL: %d"), aError); |
|
200 } |
|
201 |
|
202 // --------------------------------------------------------------------------- |
|
203 // CMPXCollectionPlaylistTest::HandleCollectionMessage |
|
204 // --------------------------------------------------------------------------- |
|
205 // |
|
206 void CMPXCollectionPlaylistTest::HandleCollectionMessage( CMPXMessage* /*aMsg*/, TInt aError ) |
|
207 { |
|
208 iLog->Log(_L("CMPXCollectionPlaylistTest::HandleCollectionMessage: %d"), aError); |
|
209 } |
|
210 |
|
211 // --------------------------------------------------------------------------- |
|
212 // CMPXCollectionPlaylistTest::HandleOpenL |
|
213 // --------------------------------------------------------------------------- |
|
214 // |
|
215 void CMPXCollectionPlaylistTest::HandleOpenL( const CMPXMedia& /*aEntries*/, TInt /*aIndex*/, TBool /*aComplete*/, TInt aError ) |
|
216 { |
|
217 iLog->Log(_L("CMPXCollectionPlaylistTest::HandleOpenL: %d"), aError); |
|
218 } |
|
219 |
|
220 // --------------------------------------------------------------------------- |
|
221 // CMPXCollectionPlaylistTest::HandleOpenL |
|
222 // --------------------------------------------------------------------------- |
|
223 // |
|
224 void CMPXCollectionPlaylistTest::HandleOpenL( const CMPXCollectionPlaylist& /*aPlaylist*/, TInt aError ) |
|
225 { |
|
226 iLog->Log(_L("CMPXCollectionPlaylistTest::HandleOpenL: %d"), aError); |
|
227 } |
|
228 |
|
229 // --------------------------------------------------------------------------- |
|
230 // CMPXCollectionPlaylistTest::HandleOpenL |
|
231 // --------------------------------------------------------------------------- |
|
232 // |
|
233 void CMPXCollectionPlaylistTest::HandleCollectionPlaylistChange( TInt aError ) |
|
234 { |
|
235 iLog->Log(_L("CMPXCollectionPlaylistTest::HandleCollectionPlaylistChange: %d"), aError); |
|
236 } |
|
237 |
|
238 // --------------------------------------------------------------------------- |
|
239 // CMPXCollectionPlaylistTest::ExampleL |
|
240 // Example test method function. |
|
241 // (other items were commented in a header). |
|
242 // --------------------------------------------------------------------------- |
|
243 // |
|
244 TInt CMPXCollectionPlaylistTest::ExampleL( CStifItemParser& aItem ) |
|
245 { |
|
246 |
|
247 // Print to UI |
|
248 _LIT( KMPXCollectionPlaylisttest, "MPXCollectionPlaylistTest" ); |
|
249 _LIT( KExample, "In Example" ); |
|
250 TestModuleIf().Printf( 0, KMPXCollectionPlaylisttest, KExample ); |
|
251 // Print to log file |
|
252 iLog->Log( KExample ); |
|
253 |
|
254 TInt i = 0; |
|
255 TPtrC string; |
|
256 _LIT( KParam, "Param[%i]: %S" ); |
|
257 while ( aItem.GetNextString( string ) == KErrNone ) |
|
258 { |
|
259 TestModuleIf().Printf( i, KMPXCollectionPlaylisttest, |
|
260 KParam, i, &string ); |
|
261 i++; |
|
262 } |
|
263 |
|
264 return KErrNone; |
|
265 } |
|
266 |
|
267 // --------------------------------------------------------------------------- |
|
268 // CMPXCollectionPlaylistTest::CreateUtilityNewPlaylist |
|
269 // ?implementation_description |
|
270 // (other items were commented in a header). |
|
271 // --------------------------------------------------------------------------- |
|
272 // |
|
273 TInt CMPXCollectionPlaylistTest::CreateUtilityNewPlaylist( CStifItemParser& /*aItem*/ ) |
|
274 { |
|
275 iLog->Log(_L("CMPXCollectionPlaylistTest::CreateUtilityNewPlaylist")); |
|
276 TRAPD(err, iCollectionPlaylist = CMPXCollectionPlaylist::NewL()); |
|
277 iLog->Log(_L("CMPXCollectionPlaylist::NewL returned: %d"), err); |
|
278 iExpectedEvents.Reset(); |
|
279 return err; |
|
280 } |
|
281 |
|
282 // --------------------------------------------------------------------------- |
|
283 // CMPXCollectionPlaylistTest::CreateUtilityPlaylistExist |
|
284 // ?implementation_description |
|
285 // (other items were commented in a header). |
|
286 // --------------------------------------------------------------------------- |
|
287 // |
|
288 TInt CMPXCollectionPlaylistTest::CreateUtilityPlaylistExist( CStifItemParser& /*aItem*/ ) |
|
289 { |
|
290 iLog->Log(_L("CMPXCollectionPlaylistTest::CreateUtilityPlaylistExist")); |
|
291 TInt err = KErrNone; |
|
292 CMPXCollectionPlaylist* firstPlaylist = NULL; |
|
293 |
|
294 // Create brand new playlist first |
|
295 TRAP(err, firstPlaylist = CMPXCollectionPlaylist::NewL()); |
|
296 iLog->Log(_L("CMPXCollectionPlaylist::NewL (firstPlaylist) returned: %d"), err); |
|
297 |
|
298 if ((err == KErrNone) && firstPlaylist) |
|
299 { |
|
300 // Pass existing playlist to create another instance of playlist |
|
301 TRAP(err, iCollectionPlaylist = CMPXCollectionPlaylist::NewL( *firstPlaylist )); |
|
302 iLog->Log(_L("CMPXCollectionPlaylist::NewL returned: %d"), err); |
|
303 } |
|
304 |
|
305 if (firstPlaylist) |
|
306 { |
|
307 delete firstPlaylist; |
|
308 } |
|
309 |
|
310 iExpectedEvents.Reset(); |
|
311 return err; |
|
312 } |
|
313 |
|
314 // --------------------------------------------------------------------------- |
|
315 // CMPXCollectionPlaylistTest::CreateUtilityCollectionPath |
|
316 // ?implementation_description |
|
317 // (other items were commented in a header). |
|
318 // --------------------------------------------------------------------------- |
|
319 // |
|
320 TInt CMPXCollectionPlaylistTest::CreateUtilityCollectionPath( CStifItemParser& /*aItem*/ ) |
|
321 { |
|
322 iLog->Log(_L("CMPXCollectionPlaylistTest::CreateUtilityCollectionPath")); |
|
323 TInt err = KErrNone; |
|
324 |
|
325 TRAP(err, BuildCollectionPathL()); |
|
326 if ((err == KErrNone) && iCollectionPath) |
|
327 { |
|
328 // Pass existing collection path to create playlist |
|
329 TRAP(err, iCollectionPlaylist = CMPXCollectionPlaylist::NewL( *iCollectionPath )); |
|
330 iLog->Log(_L("CMPXCollectionPlaylist::NewL returned: %d"), err); |
|
331 } |
|
332 |
|
333 iExpectedEvents.Reset(); |
|
334 return err; |
|
335 } |
|
336 |
|
337 // --------------------------------------------------------------------------- |
|
338 // CMPXCollectionPlaylistTest::CreateUtilityCollectionStream |
|
339 // ?implementation_description |
|
340 // (other items were commented in a header). |
|
341 // --------------------------------------------------------------------------- |
|
342 // |
|
343 TInt CMPXCollectionPlaylistTest::CreateUtilityCollectionStream( CStifItemParser& /*aItem*/ ) |
|
344 { |
|
345 iLog->Log(_L("CMPXCollectionPlaylistTest::CreateUtilityCollectionStream")); |
|
346 TInt err = KErrNone; |
|
347 CMPXCollectionPlaylist* firstPlaylist = NULL; |
|
348 |
|
349 // Create brand new playlist first |
|
350 TRAP(err, firstPlaylist = CMPXCollectionPlaylist::NewL()); |
|
351 iLog->Log(_L("CMPXCollectionPlaylist::NewL (firstPlaylist) returned: %d"), err); |
|
352 |
|
353 if ((err == KErrNone) && firstPlaylist) |
|
354 { |
|
355 // Pass stream to create another instance of playlist |
|
356 CBufBase* buffer; |
|
357 TRAP(err,buffer = CBufFlat::NewL( 200 )); |
|
358 CleanupStack::PushL( buffer ); |
|
359 RBufWriteStream writeStream( *buffer ); |
|
360 CleanupClosePushL( writeStream ); |
|
361 TRAP( err,firstPlaylist->ExternalizeL( writeStream )); |
|
362 TRAP( err,writeStream.CommitL()); |
|
363 buffer->Compress(); |
|
364 CleanupStack::PopAndDestroy( &writeStream ); |
|
365 |
|
366 RBufReadStream readStream( *buffer ); |
|
367 CleanupClosePushL( readStream ); |
|
368 TRAP( err,iCollectionPlaylist = CMPXCollectionPlaylist::NewL(readStream)); |
|
369 iLog->Log(_L("CMPXCollectionPlaylist::NewL returned: %d"), err); |
|
370 CleanupStack::PopAndDestroy( &readStream ); |
|
371 CleanupStack::PopAndDestroy( buffer ); |
|
372 } |
|
373 if (firstPlaylist) |
|
374 { |
|
375 delete firstPlaylist; |
|
376 } |
|
377 iExpectedEvents.Reset(); |
|
378 |
|
379 return err; |
|
380 } |
|
381 |
|
382 // --------------------------------------------------------------------------- |
|
383 // CMPXCollectionPlaylistTest::CopyContentL |
|
384 // ?implementation_description |
|
385 // (other items were commented in a header). |
|
386 // --------------------------------------------------------------------------- |
|
387 // |
|
388 TInt CMPXCollectionPlaylistTest::CopyContentL( CStifItemParser& /*aItem*/ ) |
|
389 { |
|
390 iLog->Log(_L("CMPXCollectionPlaylistTest::CopyContentL")); |
|
391 |
|
392 TInt err = KErrNone; |
|
393 CMPXCollectionPlaylist* anotherPlaylist = NULL; |
|
394 |
|
395 // Create another playlist to copy content from |
|
396 TRAP(err, anotherPlaylist = CMPXCollectionPlaylist::NewL()); |
|
397 iLog->Log(_L("CMPXCollectionPlaylist::NewL (anotherPlaylist) returned: %d"), err); |
|
398 |
|
399 if ((err == KErrNone) && anotherPlaylist) |
|
400 { |
|
401 anotherPlaylist->CopyContentL (*iCollectionPlaylist); |
|
402 if ((iCollectionPlaylist->RepeatMode() == anotherPlaylist->RepeatMode()) && |
|
403 (iCollectionPlaylist->Shuffle() == anotherPlaylist->Shuffle()) && |
|
404 (iCollectionPlaylist->Remote() == anotherPlaylist->Remote()) && |
|
405 (iCollectionPlaylist->Count() == anotherPlaylist->Count()) && |
|
406 (iCollectionPlaylist->Levels() == anotherPlaylist->Levels()) && |
|
407 (iCollectionPlaylist->Index() == anotherPlaylist->Index()) && |
|
408 (iCollectionPlaylist->EmbeddedPlaylist() == anotherPlaylist->EmbeddedPlaylist())) |
|
409 { |
|
410 err = KErrNone; |
|
411 iLog->Log(_L("CMPXCollectionPlaylistTest::CopyContentL copy OK")); |
|
412 } |
|
413 else |
|
414 { |
|
415 err = KErrGeneral; |
|
416 iLog->Log(_L("CMPXCollectionPlaylistTest::CopyContentL copy FAIL")); |
|
417 } |
|
418 } |
|
419 |
|
420 if (anotherPlaylist) |
|
421 { |
|
422 delete anotherPlaylist; |
|
423 } |
|
424 |
|
425 return err; |
|
426 } |
|
427 |
|
428 // --------------------------------------------------------------------------- |
|
429 // CMPXCollectionPlaylistTest::Next |
|
430 // ?implementation_description |
|
431 // (other items were commented in a header). |
|
432 // --------------------------------------------------------------------------- |
|
433 // |
|
434 TInt CMPXCollectionPlaylistTest::Next( CStifItemParser& aItem ) |
|
435 { |
|
436 iLog->Log(_L("CMPXCollectionPlaylistTest::Next")); |
|
437 TInt err = KErrNone; |
|
438 TInt vRepeatIgnored; |
|
439 TBool vRetNext; |
|
440 |
|
441 if ((KErrNone == aItem.GetNextInt(vRepeatIgnored)) && |
|
442 (vRepeatIgnored >= EFalse) && (vRepeatIgnored <= ETrue)) |
|
443 { |
|
444 vRetNext = iCollectionPlaylist->Next (vRepeatIgnored); |
|
445 iLog->Log(_L("CMPXCollectionPlaylist::Next returned: %d"), vRetNext); |
|
446 } |
|
447 else |
|
448 { |
|
449 iLog->Log(_L("CMPXCollectionPlaylistTest::Next: Bad parameter on config file")); |
|
450 err = KErrBadTestParameter; |
|
451 } |
|
452 return err; |
|
453 } |
|
454 |
|
455 // --------------------------------------------------------------------------- |
|
456 // CMPXCollectionPlaylistTest::Previous |
|
457 // ?implementation_description |
|
458 // (other items were commented in a header). |
|
459 // --------------------------------------------------------------------------- |
|
460 // |
|
461 TInt CMPXCollectionPlaylistTest::Previous( CStifItemParser& aItem ) |
|
462 { |
|
463 iLog->Log(_L("CMPXCollectionPlaylistTest::Previous")); |
|
464 TInt err = KErrNone; |
|
465 TBool vRepeatIgnored; |
|
466 TBool vRetNext; |
|
467 |
|
468 if ((KErrNone == aItem.GetNextInt(vRepeatIgnored)) && |
|
469 (vRepeatIgnored >= EFalse) && (vRepeatIgnored <= ETrue)) |
|
470 { |
|
471 vRetNext = iCollectionPlaylist->Previous (vRepeatIgnored); |
|
472 iLog->Log(_L("CMPXCollectionPlaylist::Previous returned: %d"), vRetNext); |
|
473 } |
|
474 else |
|
475 { |
|
476 iLog->Log(_L("CMPXCollectionPlaylistTest::Previous: Bad parameter on config file")); |
|
477 err = KErrBadTestParameter; |
|
478 } |
|
479 return err; |
|
480 } |
|
481 |
|
482 // --------------------------------------------------------------------------- |
|
483 // CMPXCollectionPlaylistTest::SetToFirst |
|
484 // ?implementation_description |
|
485 // (other items were commented in a header). |
|
486 // --------------------------------------------------------------------------- |
|
487 // |
|
488 TInt CMPXCollectionPlaylistTest::SetToFirst( CStifItemParser& /*aItem*/ ) |
|
489 { |
|
490 iLog->Log(_L("CMPXCollectionPlaylistTest::SetToFirst")); |
|
491 TInt err = KErrNone; |
|
492 iCollectionPlaylist->SetToFirst(); |
|
493 iLog->Log(_L("CMPXCollectionPlaylist::SetToFirst OK")); |
|
494 return err; |
|
495 } |
|
496 |
|
497 // --------------------------------------------------------------------------- |
|
498 // CMPXCollectionPlaylistTest::SetToLast |
|
499 // ?implementation_description |
|
500 // (other items were commented in a header). |
|
501 // --------------------------------------------------------------------------- |
|
502 // |
|
503 TInt CMPXCollectionPlaylistTest::SetToLast( CStifItemParser& /*aItem*/ ) |
|
504 { |
|
505 iLog->Log(_L("CMPXCollectionPlaylistTest::SetToLast")); |
|
506 TInt err = KErrNone; |
|
507 iCollectionPlaylist->SetToLast(); |
|
508 iLog->Log(_L("CMPXCollectionPlaylist::SetToLast OK")); |
|
509 return err; |
|
510 } |
|
511 |
|
512 // --------------------------------------------------------------------------- |
|
513 // CMPXCollectionPlaylistTest::SetToIndex |
|
514 // ?implementation_description |
|
515 // (other items were commented in a header). |
|
516 // --------------------------------------------------------------------------- |
|
517 // |
|
518 TInt CMPXCollectionPlaylistTest::SetToIndex( CStifItemParser& aItem ) |
|
519 { |
|
520 iLog->Log(_L("CMPXCollectionPlaylistTest::SetToIndex")); |
|
521 TInt err = KErrNone; |
|
522 TInt vIndex; |
|
523 if ( KErrNone == aItem.GetNextInt(vIndex) ) |
|
524 { |
|
525 TInt vCount = iCollectionPlaylist->Count(); |
|
526 iLog->Log(_L("CMPXCollectionPlaylist::Count returned: %d"), vCount); |
|
527 if ((vCount > 0) && (vIndex < vCount)) |
|
528 { |
|
529 iCollectionPlaylist->SetToIndex (vIndex); |
|
530 iLog->Log(_L("CMPXCollectionPlaylist::SetToIndex OK")); |
|
531 } |
|
532 else |
|
533 { |
|
534 iLog->Log(_L("CMPXCollectionPlaylist::SetToIndex FAIL")); |
|
535 } |
|
536 } |
|
537 else |
|
538 { |
|
539 iLog->Log(_L("CMPXCollectionPlaylistTest::SetToIndex: Bad parameter on config file")); |
|
540 err = KErrBadTestParameter; |
|
541 } |
|
542 return err; |
|
543 } |
|
544 |
|
545 // --------------------------------------------------------------------------- |
|
546 // CMPXCollectionPlaylistTest::Count |
|
547 // ?implementation_description |
|
548 // (other items were commented in a header). |
|
549 // --------------------------------------------------------------------------- |
|
550 // |
|
551 TInt CMPXCollectionPlaylistTest::Count( CStifItemParser& /*aItem*/ ) |
|
552 { |
|
553 iLog->Log(_L("CMPXCollectionPlaylistTest::Count")); |
|
554 TInt err = KErrNone; |
|
555 TInt vCount = iCollectionPlaylist->Count(); |
|
556 iLog->Log(_L("CMPXCollectionPlaylist::Count returned: %d"), vCount); |
|
557 return err; |
|
558 } |
|
559 |
|
560 // --------------------------------------------------------------------------- |
|
561 // CMPXCollectionPlaylistTest::Levels |
|
562 // ?implementation_description |
|
563 // (other items were commented in a header). |
|
564 // --------------------------------------------------------------------------- |
|
565 // |
|
566 TInt CMPXCollectionPlaylistTest::Levels( CStifItemParser& /*aItem*/ ) |
|
567 { |
|
568 iLog->Log(_L("CMPXCollectionPlaylistTest::Levels")); |
|
569 TInt err = KErrNone; |
|
570 TInt vLevels = iCollectionPlaylist->Levels(); |
|
571 iLog->Log(_L("CMPXCollectionPlaylist::Levels returned: %d"), vLevels); |
|
572 return err; |
|
573 } |
|
574 |
|
575 // --------------------------------------------------------------------------- |
|
576 // CMPXCollectionPlaylistTest::Index |
|
577 // ?implementation_description |
|
578 // (other items were commented in a header). |
|
579 // --------------------------------------------------------------------------- |
|
580 // |
|
581 TInt CMPXCollectionPlaylistTest::Index( CStifItemParser& /*aItem*/ ) |
|
582 { |
|
583 iLog->Log(_L("CMPXCollectionPlaylistTest::Index")); |
|
584 TInt err = KErrNone; |
|
585 TInt vIndex = iCollectionPlaylist->Index(); |
|
586 iLog->Log(_L("CMPXCollectionPlaylist::Index returned: %d"), vIndex); |
|
587 return err; |
|
588 } |
|
589 |
|
590 // --------------------------------------------------------------------------- |
|
591 // CMPXCollectionPlaylistTest::Remote |
|
592 // ?implementation_description |
|
593 // (other items were commented in a header). |
|
594 // --------------------------------------------------------------------------- |
|
595 // |
|
596 TInt CMPXCollectionPlaylistTest::Remote( CStifItemParser& /*aItem*/ ) |
|
597 { |
|
598 iLog->Log(_L("CMPXCollectionPlaylistTest::Remote")); |
|
599 TInt err = KErrNone; |
|
600 TBool vIsCollectionStoredInRemoteDevice = iCollectionPlaylist->Remote(); |
|
601 iLog->Log(_L("CMPXCollectionPlaylist::Remote returned: %d"), vIsCollectionStoredInRemoteDevice); |
|
602 return err; |
|
603 } |
|
604 |
|
605 // --------------------------------------------------------------------------- |
|
606 // CMPXCollectionPlaylistTest::RepeatMode |
|
607 // ?implementation_description |
|
608 // (other items were commented in a header). |
|
609 // --------------------------------------------------------------------------- |
|
610 // |
|
611 TInt CMPXCollectionPlaylistTest::RepeatMode( CStifItemParser& /*aItem*/ ) |
|
612 { |
|
613 iLog->Log(_L("CMPXCollectionPlaylistTest::RepeatMode")); |
|
614 TInt err = KErrNone; |
|
615 TInt vRepeatMode = iCollectionPlaylist->RepeatMode(); |
|
616 iLog->Log(_L("CMPXCollectionPlaylist::RepeatMode returned: %d"), vRepeatMode); |
|
617 return err; |
|
618 } |
|
619 |
|
620 // --------------------------------------------------------------------------- |
|
621 // CMPXCollectionPlaylistTest::Shuffle |
|
622 // ?implementation_description |
|
623 // (other items were commented in a header). |
|
624 // --------------------------------------------------------------------------- |
|
625 // |
|
626 TInt CMPXCollectionPlaylistTest::Shuffle( CStifItemParser& /*aItem*/ ) |
|
627 { |
|
628 iLog->Log(_L("CMPXCollectionPlaylistTest::Shuffle")); |
|
629 TInt err = KErrNone; |
|
630 TBool vIsShuffleOn = iCollectionPlaylist->Shuffle(); |
|
631 iLog->Log(_L("CMPXCollectionPlaylist::Shuffle returned: %d"), vIsShuffleOn); |
|
632 return err; |
|
633 } |
|
634 |
|
635 // --------------------------------------------------------------------------- |
|
636 // CMPXCollectionPlaylistTest::Path |
|
637 // ?implementation_description |
|
638 // (other items were commented in a header). |
|
639 // --------------------------------------------------------------------------- |
|
640 // |
|
641 TInt CMPXCollectionPlaylistTest::Path( CStifItemParser& /*aItem*/ ) |
|
642 { |
|
643 iLog->Log(_L("CMPXCollectionPlaylistTest::Path")); |
|
644 TInt err = KErrNone; |
|
645 // CMPXCollectionPath& vPath = (CMPXCollectionPath&)iCollectionPlaylist->Path(); |
|
646 TRAP(err,iCollectionPlaylist->Path()); |
|
647 if ( err != KErrNone ) |
|
648 { |
|
649 iLog->Log(_L("Path returned: %d"), err); |
|
650 } |
|
651 // iLog->Log(_L("CMPXCoiCollectionPlaylist->Path()llectionPlaylist::Path returned: %d"), vPath); |
|
652 |
|
653 |
|
654 return err; |
|
655 } |
|
656 |
|
657 // --------------------------------------------------------------------------- |
|
658 // CMPXCollectionPlaylistTest::MediaL |
|
659 // ?implementation_description |
|
660 // (other items were commented in a header). |
|
661 // --------------------------------------------------------------------------- |
|
662 // |
|
663 TInt CMPXCollectionPlaylistTest::MediaL( CStifItemParser& /*aItem*/ ) |
|
664 { |
|
665 iLog->Log(_L("CMPXCollectionPlaylistTest::MediaL")); |
|
666 TInt err = KErrNone; |
|
667 // CDesCArrayFlat* aLinkArray = new (ELeave) CDesCArrayFlat(1); |
|
668 RArray<TMPXAttribute> attrs; |
|
669 CleanupClosePushL( attrs ); |
|
670 // attrs.Append( KMPXMediaGeneralTitle ); |
|
671 // TArray<TMPXAttribute>& ary = attrs.Array(); |
|
672 // TArray<TMPXAttribute>& aAttrs=new (ELeave) TArray<TMPXAttribute> ; |
|
673 TRAP(err, iCollectionPlaylist->MediaL(attrs.Array(),*this)); |
|
674 CleanupStack::PopAndDestroy( &attrs ); |
|
675 if ( err != KErrNone ) |
|
676 { |
|
677 iLog->Log(_L("MediaL returned: %d"), err); |
|
678 } |
|
679 return err; |
|
680 } |
|
681 |
|
682 // --------------------------------------------------------------------------- |
|
683 // CMPXCollectionPlaylistTest::SetRepeatMode |
|
684 // ?implementation_description |
|
685 // (other items were commented in a header). |
|
686 // --------------------------------------------------------------------------- |
|
687 // |
|
688 TInt CMPXCollectionPlaylistTest::SetRepeatMode( CStifItemParser& aItem ) |
|
689 { |
|
690 iLog->Log(_L("CMPXCollectionPlaylistTest::SetRepeatMode")); |
|
691 TInt err = KErrNone; |
|
692 TInt vRepeatMode; |
|
693 if ((KErrNone == aItem.GetNextInt(vRepeatMode)) && |
|
694 (vRepeatMode >= CMPXCollectionPlaylist::ERepeatOff) && (vRepeatMode <= CMPXCollectionPlaylist::ERepeatAll)) |
|
695 { |
|
696 iCollectionPlaylist->SetRepeatMode ((CMPXCollectionPlaylist::TRepeatMode) vRepeatMode); |
|
697 iLog->Log(_L("CMPXCollectionPlaylist::SetRepeatMode OK")); |
|
698 } |
|
699 else |
|
700 { |
|
701 iLog->Log(_L("CMPXCollectionPlaylistTest::SetRepeatMode: Bad parameter on config file")); |
|
702 err = KErrBadTestParameter; |
|
703 } |
|
704 return err; |
|
705 } |
|
706 |
|
707 // --------------------------------------------------------------------------- |
|
708 // CMPXCollectionPlaylistTest::SetRepeatEnabled |
|
709 // ?implementation_description |
|
710 // (other items were commented in a header). |
|
711 // --------------------------------------------------------------------------- |
|
712 // |
|
713 TInt CMPXCollectionPlaylistTest::SetRepeatEnabled( CStifItemParser& aItem ) |
|
714 { |
|
715 iLog->Log(_L("CMPXCollectionPlaylistTest::SetRepeatEnabled")); |
|
716 TInt err = KErrNone; |
|
717 TInt vRepeatEnabled; |
|
718 if ((KErrNone == aItem.GetNextInt(vRepeatEnabled)) && |
|
719 (vRepeatEnabled >= EFalse) && (vRepeatEnabled <= ETrue)) |
|
720 { |
|
721 iCollectionPlaylist->SetRepeatEnabled (vRepeatEnabled); |
|
722 iLog->Log(_L("CMPXCollectionPlaylist::SetRepeatEnabled OK")); |
|
723 } |
|
724 else |
|
725 { |
|
726 iLog->Log(_L("CMPXCollectionPlaylistTest::SetRepeatEnabled: Bad parameter on config file")); |
|
727 err = KErrBadTestParameter; |
|
728 } |
|
729 return err; |
|
730 } |
|
731 |
|
732 // --------------------------------------------------------------------------- |
|
733 // CMPXCollectionPlaylistTest::SetShuffleL |
|
734 // ?implementation_description |
|
735 // (other items were commented in a header). |
|
736 // --------------------------------------------------------------------------- |
|
737 // |
|
738 TInt CMPXCollectionPlaylistTest::SetShuffleL( CStifItemParser& aItem ) |
|
739 { |
|
740 iLog->Log(_L("CMPXCollectionPlaylistTest::SetShuffleL")); |
|
741 TInt err = KErrNone; |
|
742 TInt vShuffle; |
|
743 TInt vCurrentToTop; |
|
744 if ((KErrNone == aItem.GetNextInt(vShuffle)) && |
|
745 (vShuffle >= 0) && (vShuffle <=1)) |
|
746 { |
|
747 if ((KErrNone == aItem.GetNextInt(vCurrentToTop)) && |
|
748 (vCurrentToTop >= EFalse) && (vCurrentToTop <= ETrue)) |
|
749 { |
|
750 TRAP (err, iCollectionPlaylist->SetShuffleL (vShuffle, vCurrentToTop)); |
|
751 if (err != KErrNone) |
|
752 { |
|
753 iLog->Log(_L("CMPXCollectionPlaylist::SetShuffleL leave with error: %d"), err); |
|
754 } |
|
755 else |
|
756 { |
|
757 iLog->Log(_L("CMPXCollectionPlaylist::SetShuffleL OK")); |
|
758 } |
|
759 } |
|
760 else |
|
761 { |
|
762 iLog->Log(_L("CMPXCollectionPlaylistTest::SetShuffleL: Bad second parameter on config file")); |
|
763 err = KErrBadTestParameter; |
|
764 } |
|
765 } |
|
766 else |
|
767 { |
|
768 iLog->Log(_L("CMPXCollectionPlaylistTest::SetShuffleL: Bad first parameter on config file")); |
|
769 err = KErrBadTestParameter; |
|
770 } |
|
771 return err; |
|
772 } |
|
773 |
|
774 // --------------------------------------------------------------------------- |
|
775 // CMPXCollectionPlaylistTest::SetShuffleEnabledL |
|
776 // ?implementation_description |
|
777 // (other items were commented in a header). |
|
778 // --------------------------------------------------------------------------- |
|
779 // |
|
780 TInt CMPXCollectionPlaylistTest::SetShuffleEnabledL( CStifItemParser& aItem ) |
|
781 { |
|
782 iLog->Log(_L("CMPXCollectionPlaylistTest::SetShuffleEnabledL")); |
|
783 TInt err = KErrNone; |
|
784 TInt vShuffleEnabled; |
|
785 if ((KErrNone == aItem.GetNextInt(vShuffleEnabled)) && |
|
786 (vShuffleEnabled >= EFalse) && (vShuffleEnabled <= ETrue)) |
|
787 { |
|
788 TRAP (err, iCollectionPlaylist->SetShuffleEnabledL (vShuffleEnabled)); |
|
789 if (err != KErrNone) |
|
790 { |
|
791 iLog->Log(_L("CMPXCollectionPlaylist::SetShuffleEnabledL leave with error: %d"), err); |
|
792 } |
|
793 else |
|
794 { |
|
795 iLog->Log(_L("CMPXCollectionPlaylist::SetShuffleEnabledL OK")); |
|
796 } |
|
797 } |
|
798 else |
|
799 { |
|
800 iLog->Log(_L("CMPXCollectionPlaylistTest::SetShuffleEnabledL: Bad parameter on config file")); |
|
801 err = KErrBadTestParameter; |
|
802 } |
|
803 return err; |
|
804 } |
|
805 |
|
806 // --------------------------------------------------------------------------- |
|
807 // CMPXCollectionPlaylistTest::StreamingL |
|
808 // ?implementation_description |
|
809 // (other items were commented in a header). |
|
810 // --------------------------------------------------------------------------- |
|
811 // |
|
812 TInt CMPXCollectionPlaylistTest::StreamingL( CStifItemParser& /*aItem*/ ) |
|
813 { |
|
814 iLog->Log(_L("CMPXCollectionPlaylistTest::StreamingL")); |
|
815 TInt err = KErrNone; |
|
816 |
|
817 iLog->Log(_L("Start ExternalizeL")); |
|
818 CBufBase* buffer = CBufFlat::NewL( 200 ); |
|
819 CleanupStack::PushL( buffer ); |
|
820 RBufWriteStream writeStream( *buffer ); |
|
821 CleanupClosePushL( writeStream ); |
|
822 iCollectionPlaylist->ExternalizeL( writeStream ); |
|
823 writeStream.CommitL(); |
|
824 buffer->Compress(); |
|
825 CleanupStack::PopAndDestroy( &writeStream ); |
|
826 |
|
827 iLog->Log(_L("Start InternalizeL")); |
|
828 RBufReadStream readStream( *buffer ); |
|
829 CleanupClosePushL( readStream ); |
|
830 CMPXCollectionPlaylist* collPlaylist = CMPXCollectionPlaylist::NewL(); |
|
831 CleanupStack::PushL( collPlaylist ); |
|
832 collPlaylist->InternalizeL( readStream ); |
|
833 |
|
834 CleanupStack::PopAndDestroy( collPlaylist ); |
|
835 CleanupStack::PopAndDestroy( &readStream ); |
|
836 CleanupStack::PopAndDestroy( buffer ); |
|
837 return err; |
|
838 } |
|
839 |
|
840 // --------------------------------------------------------------------------- |
|
841 // CMPXCollectionPlaylistTest::SetObserver |
|
842 // ?implementation_description |
|
843 // (other items were commented in a header). |
|
844 // --------------------------------------------------------------------------- |
|
845 // |
|
846 TInt CMPXCollectionPlaylistTest::SetObserver( CStifItemParser& /*aItem*/ ) |
|
847 { |
|
848 iLog->Log(_L("CMPXCollectionPlaylistTest::SetObserver")); |
|
849 TInt err = KErrNone; |
|
850 MMPXCollectionPlaylistObserver* aPlObs(NULL) ; |
|
851 MMPXCollectionObserver* aCollectionObs(NULL) ; |
|
852 TRAP(err,iCollectionPlaylist->SetObserver(*this,aPlObs,aCollectionObs)); |
|
853 if ( err != KErrNone ) |
|
854 { |
|
855 iLog->Log(_L("SetObserver returned: %d"), err); |
|
856 } |
|
857 return err; |
|
858 } |
|
859 |
|
860 |
|
861 // --------------------------------------------------------------------------- |
|
862 // CMPXCollectionPlaylistTest::EmbeddedPlaylist |
|
863 // ?implementation_description |
|
864 // (other items were commented in a header). |
|
865 // --------------------------------------------------------------------------- |
|
866 // |
|
867 TInt CMPXCollectionPlaylistTest::EmbeddedPlaylist( CStifItemParser& /*aItem*/ ) |
|
868 { |
|
869 iLog->Log(_L("CMPXCollectionPlaylistTest::EmbeddedPlaylist")); |
|
870 TInt err = KErrNone; |
|
871 TBool vIsEmbeddedPlaylist = iCollectionPlaylist->EmbeddedPlaylist(); |
|
872 iLog->Log(_L("CMPXCollectionPlaylist::EmbeddedPlaylist returned: %d"), vIsEmbeddedPlaylist); |
|
873 return err; |
|
874 } |
|
875 |
|
876 // --------------------------------------------------------------------------- |
|
877 // CMPXCollectionPlaylistTest::SetEmbeddedPlaylist |
|
878 // ?implementation_description |
|
879 // (other items were commented in a header). |
|
880 // --------------------------------------------------------------------------- |
|
881 // |
|
882 TInt CMPXCollectionPlaylistTest::SetEmbeddedPlaylist( CStifItemParser& aItem ) |
|
883 { |
|
884 iLog->Log(_L("CMPXCollectionPlaylistTest::SetEmbeddedPlaylist")); |
|
885 TInt err = KErrNone; |
|
886 TInt vEmbeddedPlaylist; |
|
887 if ((KErrNone == aItem.GetNextInt(vEmbeddedPlaylist)) && |
|
888 (vEmbeddedPlaylist >= EFalse) && (vEmbeddedPlaylist <= ETrue)) |
|
889 { |
|
890 iCollectionPlaylist->SetEmbeddedPlaylist (vEmbeddedPlaylist); |
|
891 iLog->Log(_L("CMPXCollectionPlaylist::SetEmbeddedPlaylist OK")); |
|
892 } |
|
893 else |
|
894 { |
|
895 iLog->Log(_L("CMPXCollectionPlaylistTest::SetEmbeddedPlaylist: Bad parameter on config file")); |
|
896 err = KErrBadTestParameter; |
|
897 } |
|
898 return err; |
|
899 } |
|
900 |
|
901 // --------------------------------------------------------------------------- |
|
902 // CMPXCollectionPlaylistTest::SetL |
|
903 // ?implementation_description |
|
904 // (other items were commented in a header). |
|
905 // --------------------------------------------------------------------------- |
|
906 // |
|
907 TInt CMPXCollectionPlaylistTest::SetL( CStifItemParser& /*aItem*/ ) |
|
908 { |
|
909 iLog->Log(_L("CMPXCollectionPlaylistTest::SetL")); |
|
910 TInt err = KErrNone; |
|
911 |
|
912 CMPXMedia* media = CMPXMedia::NewL(); |
|
913 CleanupStack::PushL( media ); |
|
914 media->SetTObjectValueL<TUid>( KMPXMediaGeneralCollectionId, TUid::Uid(0xabcdef) ); |
|
915 TRAP(err,iCollectionPlaylist->SetL( *media )); |
|
916 CleanupStack::PopAndDestroy( media ); |
|
917 |
|
918 if ( err != KErrNone ) |
|
919 { |
|
920 iLog->Log(_L("SetL returned: %d"), err); |
|
921 } |
|
922 return err; |
|
923 } |
|
924 |
|
925 // --------------------------------------------------------------------------- |
|
926 // CMPXCollectionPlaylistTest::CancelRequest |
|
927 // ?implementation_description |
|
928 // (other items were commented in a header). |
|
929 // --------------------------------------------------------------------------- |
|
930 // |
|
931 TInt CMPXCollectionPlaylistTest::CancelRequest( CStifItemParser& /*aItem*/ ) |
|
932 { |
|
933 iLog->Log(_L("CMPXCollectionPlaylistTest::CancelRequest")); |
|
934 TInt err = KErrNone; |
|
935 iCollectionPlaylist->CancelRequest(); |
|
936 iLog->Log(_L("CMPXCollectionPlaylist::CancelRequest OK")); |
|
937 return err; |
|
938 } |
|
939 |
|
940 // --------------------------------------------------------------------------- |
|
941 // CMPXCollectionPlaylistTest::Invalidate |
|
942 // ?implementation_description |
|
943 // (other items were commented in a header). |
|
944 // --------------------------------------------------------------------------- |
|
945 // |
|
946 TInt CMPXCollectionPlaylistTest::Invalidate( CStifItemParser& /*aItem*/ ) |
|
947 { |
|
948 iLog->Log(_L("CMPXCollectionPlaylistTest::Invalidate")); |
|
949 TInt err = KErrNone; |
|
950 iCollectionPlaylist->Invalidate(); |
|
951 iLog->Log(_L("CMPXCollectionPlaylist::Invalidate OK")); |
|
952 return err; |
|
953 } |
|
954 |
|
955 // --------------------------------------------------------------------------- |
|
956 // CMPXCollectionPlaylistTest::NextIndex |
|
957 // ?implementation_description |
|
958 // (other items were commented in a header). |
|
959 // --------------------------------------------------------------------------- |
|
960 // |
|
961 TInt CMPXCollectionPlaylistTest::NextIndex( CStifItemParser& aItem ) |
|
962 { |
|
963 iLog->Log(_L("CMPXCollectionPlaylistTest::NextIndex")); |
|
964 TInt err = KErrNone; |
|
965 TInt vRepeatIgnored; |
|
966 TBool vRetNext; |
|
967 TInt aPlaylistIndex; |
|
968 if ((KErrNone == aItem.GetNextInt(vRepeatIgnored)) && |
|
969 (vRepeatIgnored >= EFalse) && (vRepeatIgnored <= ETrue)) |
|
970 { |
|
971 vRetNext = iCollectionPlaylist->NextIndex(vRepeatIgnored ,aPlaylistIndex); |
|
972 iLog->Log(_L("CMPXCollectionPlaylist::NextIndex returned: %d"), vRetNext); |
|
973 } |
|
974 else |
|
975 { |
|
976 iLog->Log(_L("CMPXCollectionPlaylistTest::NextIndex: Bad parameter on config file")); |
|
977 err = KErrBadTestParameter; |
|
978 } |
|
979 return err; |
|
980 } |
|
981 |
|
982 // --------------------------------------------------------------------------- |
|
983 // CMPXCollectionPlaylistTest::PathIndex |
|
984 // ?implementation_description |
|
985 // (other items were commented in a header). |
|
986 // --------------------------------------------------------------------------- |
|
987 // |
|
988 TInt CMPXCollectionPlaylistTest::PathIndex( CStifItemParser& aItem ) |
|
989 { |
|
990 iLog->Log(_L("CMPXCollectionPlaylistTest::PathIndex")); |
|
991 TInt err = KErrNone; |
|
992 TInt err1 = KErrNone; |
|
993 TInt vRepeatIgnored; |
|
994 TBool vRetNext; |
|
995 TInt aPlaylistIndex; |
|
996 if ((KErrNone == aItem.GetNextInt(vRepeatIgnored)) && |
|
997 (vRepeatIgnored >= EFalse) && (vRepeatIgnored <= ETrue)) |
|
998 { |
|
999 vRetNext = iCollectionPlaylist->NextIndex(vRepeatIgnored ,aPlaylistIndex); |
|
1000 // vRetNext = iCollectionPlaylist->Next(vRepeatIgnored ); |
|
1001 err1 = iCollectionPlaylist->PathIndex( aPlaylistIndex ); |
|
1002 iLog->Log(_L("CMPXCollectionPlaylist::NextIndex returned: %d"), vRetNext); |
|
1003 iLog->Log(_L("CMPXCollectionPlaylist::PathIndex returned: %d"), err1); |
|
1004 |
|
1005 } |
|
1006 else |
|
1007 { |
|
1008 iLog->Log(_L("CMPXCollectionPlaylistTest::PathIndex: Bad parameter on config file")); |
|
1009 err = KErrBadTestParameter; |
|
1010 } |
|
1011 return err; |
|
1012 } |
|
1013 |
|
1014 // --------------------------------------------------------------------------- |
|
1015 // CMPXCollectionPlaylistTest::CMPXCollectionPlaylistDestructor |
|
1016 // ?implementation_description |
|
1017 // (other items were commented in a header). |
|
1018 // --------------------------------------------------------------------------- |
|
1019 // |
|
1020 TInt CMPXCollectionPlaylistTest::CMPXCollectionPlaylistDestructor( CStifItemParser& /*aItem*/ ) |
|
1021 { |
|
1022 iLog->Log(_L("CMPXCollectionPlaylistTest::CMPXCollectionPlaylistDestructor")); |
|
1023 TInt err = KErrNone; |
|
1024 if( iCollectionPlaylist != NULL ) |
|
1025 { |
|
1026 delete iCollectionPlaylist; |
|
1027 iCollectionPlaylist = NULL; |
|
1028 } |
|
1029 if( iCollectionPlaylist != NULL ) |
|
1030 { |
|
1031 iLog->Log(_L("CMPXCollectionPlaylist::CMPXCollectionPlaylistDestructor err="),err); |
|
1032 } |
|
1033 return err; |
|
1034 } |
|
1035 |
|
1036 // --------------------------------------------------------------------------- |
|
1037 // CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityCreate |
|
1038 // ?implementation_description |
|
1039 // (other items were commented in a header). |
|
1040 // --------------------------------------------------------------------------- |
|
1041 // |
|
1042 TInt CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityCreate( CStifItemParser& /*aItem*/ ) |
|
1043 { |
|
1044 TInt err = KErrNone; |
|
1045 |
|
1046 MMPXCollectionObserver* aObs(NULL); |
|
1047 iLog->Log(_L("CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityCreate")); |
|
1048 TRAP( err , iCollectionOpenUtility=CMPXCollectionOpenUtility::NewL(aObs)); |
|
1049 if( iCollectionOpenUtility != NULL ) |
|
1050 { |
|
1051 delete iCollectionOpenUtility; |
|
1052 iCollectionOpenUtility = NULL; |
|
1053 } |
|
1054 iLog->Log(_L("CMPXCollectionOpenUtility::NewL returned: %d"), err); |
|
1055 return err; |
|
1056 } |
|
1057 |
|
1058 |
|
1059 // --------------------------------------------------------------------------- |
|
1060 // CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartL |
|
1061 // ?implementation_description |
|
1062 // (other items were commented in a header). |
|
1063 // --------------------------------------------------------------------------- |
|
1064 // |
|
1065 TInt CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartL( CStifItemParser& ) |
|
1066 { |
|
1067 iLog->Log(_L("CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartL")); |
|
1068 TInt err = KErrNone; |
|
1069 RArray<TMPXAttribute> aAttrs; |
|
1070 CleanupClosePushL( aAttrs ); |
|
1071 TMPXAttribute attribut = TMPXAttribute(); |
|
1072 aAttrs.AppendL(attribut); |
|
1073 TInt aChunkSize=0; |
|
1074 TRAP( err , iCollectionPlaylist = CMPXCollectionPlaylist::NewL()); |
|
1075 CMPXCollectionOpenUtility* utility; |
|
1076 TRAP( err , utility = CMPXCollectionOpenUtility::NewL(iCollectionPlaylist,KMcModeDefault)); |
|
1077 TRAP( err , utility->StartL(aAttrs.Array(),aChunkSize)); |
|
1078 delete utility; |
|
1079 utility = NULL; |
|
1080 CleanupStack::PopAndDestroy( &aAttrs ); |
|
1081 iLog->Log(_L("CMPXCollectionOpenUtility::CMPXCollectionOpenUtilityStartL err: %d"),err); |
|
1082 return err; |
|
1083 } |
|
1084 |
|
1085 // --------------------------------------------------------------------------- |
|
1086 // CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityPathL |
|
1087 // ?implementation_description |
|
1088 // (other items were commented in a header). |
|
1089 // --------------------------------------------------------------------------- |
|
1090 // |
|
1091 TInt CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityPathL( CStifItemParser& /*aItem*/) |
|
1092 { |
|
1093 iLog->Log(_L("CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityPathL")); |
|
1094 TInt err = KErrNone; |
|
1095 TRAP( err , iCollectionPlaylist = CMPXCollectionPlaylist::NewL()); |
|
1096 CMPXCollectionOpenUtility* utility; |
|
1097 TRAP( err , utility = CMPXCollectionOpenUtility::NewL(iCollectionPlaylist,KMcModeDefault)); |
|
1098 |
|
1099 TRAP( err ,iCollectionPath = utility->PathL()); |
|
1100 |
|
1101 if ( utility != NULL ) |
|
1102 { |
|
1103 delete utility; |
|
1104 utility = NULL; |
|
1105 } |
|
1106 iLog->Log(_L("CMPXCollectionPlaylist::CMPXCollectionOpenUtilityPathL OK")); |
|
1107 return err; |
|
1108 } |
|
1109 |
|
1110 |
|
1111 // --------------------------------------------------------------------------- |
|
1112 // CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStop |
|
1113 // ?implementation_description |
|
1114 // (other items were commented in a header). |
|
1115 // --------------------------------------------------------------------------- |
|
1116 // |
|
1117 TInt CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStop( CStifItemParser& /*aItem*/) |
|
1118 { |
|
1119 iLog->Log(_L("CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStop")); |
|
1120 TInt err = KErrNone; |
|
1121 TRAP( err , iCollectionPlaylist = CMPXCollectionPlaylist::NewL()); |
|
1122 CMPXCollectionOpenUtility* utility; |
|
1123 TRAP( err , utility = CMPXCollectionOpenUtility::NewL(iCollectionPlaylist,KMcModeDefault)); |
|
1124 |
|
1125 TRAP( err , utility->Stop()); |
|
1126 if ( utility != NULL ) |
|
1127 { |
|
1128 delete utility; |
|
1129 utility = NULL; |
|
1130 } |
|
1131 iLog->Log(_L("CMPXCollectionPlaylist::CMPXCollectionOpenUtilityStop return err: %d"),err); |
|
1132 return err; |
|
1133 } |
|
1134 |
|
1135 |
|
1136 |
|
1137 |
|
1138 // --------------------------------------------------------------------------- |
|
1139 // CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDelay |
|
1140 // ?implementation_description |
|
1141 // (other items were commented in a header). |
|
1142 // --------------------------------------------------------------------------- |
|
1143 // |
|
1144 TInt CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDelay( CStifItemParser& /*aItem*/) |
|
1145 { |
|
1146 iLog->Log(_L("CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDelay")); |
|
1147 TInt err = KErrNone; |
|
1148 TRAP( err , iCollectionPlaylist = CMPXCollectionPlaylist::NewL()); |
|
1149 CMPXCollectionOpenUtility* utility; |
|
1150 TRAP( err , utility = CMPXCollectionOpenUtility::NewL(iCollectionPlaylist,KMcModeDefault)); |
|
1151 |
|
1152 TInt delay = 10; |
|
1153 TRAP( err , utility->SetDelay(delay)); |
|
1154 if(err != KErrNone) |
|
1155 { |
|
1156 iLog->Log(_L("CMPXCollectionPlaylist::CMPXCollectionOpenUtilitySetDelay does not work right")); |
|
1157 delete utility; |
|
1158 utility = NULL; |
|
1159 return err; |
|
1160 } |
|
1161 if ( utility != NULL ) |
|
1162 { |
|
1163 delete utility; |
|
1164 utility = NULL; |
|
1165 } |
|
1166 iLog->Log(_L("CMPXCollectionPlaylist::CMPXCollectionOpenUtilitySetDelay OK")); |
|
1167 return err; |
|
1168 } |
|
1169 |
|
1170 |
|
1171 |
|
1172 // --------------------------------------------------------------------------- |
|
1173 // CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartUsingPath |
|
1174 // ?implementation_description |
|
1175 // (other items were commented in a header). |
|
1176 // --------------------------------------------------------------------------- |
|
1177 // |
|
1178 TInt CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartUsingPath( CStifItemParser& aItem ) |
|
1179 { |
|
1180 iLog->Log(_L("CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartUsingPath")); |
|
1181 TInt err = KErrNone; |
|
1182 |
|
1183 TUint itemId; |
|
1184 // read in parameters |
|
1185 if ( aItem.GetNextInt(itemId) ) |
|
1186 { |
|
1187 iLog->Log(_L("Missing Parameter: ItemId.")); |
|
1188 return KErrBadTestParameter; |
|
1189 } |
|
1190 |
|
1191 const TMPXItemId KMPXPathItem1 = 44441; |
|
1192 RArray<TMPXItemId> itemIdArray; |
|
1193 |
|
1194 // Start from scratch |
|
1195 if ( iCollectionPath ) |
|
1196 { |
|
1197 iCollectionPath->Reset(); |
|
1198 delete iCollectionPath; |
|
1199 } |
|
1200 // build collection path |
|
1201 TRAP( err , iCollectionPath = CMPXCollectionPath::NewL()); |
|
1202 TMPXItemId item(itemId); |
|
1203 TRAP( err , iCollectionPath->AppendL(item)); |
|
1204 itemIdArray.Append(KMPXPathItem1); |
|
1205 TRAP( err , iCollectionPath->AppendL(itemIdArray.Array())); |
|
1206 |
|
1207 itemIdArray.Close(); |
|
1208 |
|
1209 |
|
1210 CMPXCollectionPath* path; |
|
1211 TRAP( err , path = CMPXCollectionPath::NewL(*iCollectionPath)); |
|
1212 |
|
1213 RArray<TMPXAttribute> aAttrs; |
|
1214 aAttrs.Append(KMPXMediaGeneralTitle); |
|
1215 TInt aChunkSize=0; |
|
1216 |
|
1217 TInt aOffset = 0; |
|
1218 CMPXCollectionOpenUtility::TDirection direction = CMPXCollectionOpenUtility::EFetchNormal; |
|
1219 TMPXAttribute aKeyAttribute = KMPXMediaNullAttribute ; |
|
1220 |
|
1221 TRAP( err , iCollectionPlaylist = CMPXCollectionPlaylist::NewL()); |
|
1222 CMPXCollectionOpenUtility* utility; |
|
1223 TRAP( err , utility = CMPXCollectionOpenUtility::NewL(iCollectionPlaylist,KMcModeIsolated/*KMcModeDefault*/)); |
|
1224 TRAP( err , utility->StartL(*path,aAttrs.Array(),aChunkSize,aOffset,direction,aKeyAttribute)); |
|
1225 delete utility; |
|
1226 utility = NULL; |
|
1227 delete path; |
|
1228 aAttrs.Close(); |
|
1229 iLog->Log(_L("CMPXCollectionOpenUtility::CMPXCollectionOpenUtilityStartUsingPath err: %d"),err); |
|
1230 return err; |
|
1231 } |
|
1232 |
|
1233 |
|
1234 // --------------------------------------------------------------------------- |
|
1235 // CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDirection |
|
1236 // ?implementation_description |
|
1237 // (other items were commented in a header). |
|
1238 // --------------------------------------------------------------------------- |
|
1239 // |
|
1240 TInt CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDirection( CStifItemParser& /*aItem*/) |
|
1241 { |
|
1242 iLog->Log(_L("CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDirection")); |
|
1243 TInt err = KErrNone; |
|
1244 TRAP( err , iCollectionPlaylist = CMPXCollectionPlaylist::NewL()); |
|
1245 CMPXCollectionOpenUtility* utility; |
|
1246 TRAP( err , utility = CMPXCollectionOpenUtility::NewL(iCollectionPlaylist,KMcModeDefault)); |
|
1247 CMPXCollectionOpenUtility::TDirection direction = CMPXCollectionOpenUtility::EFetchNormal; |
|
1248 TRAP( err , utility->SetDirection(direction)); |
|
1249 if( err != KErrNone ) |
|
1250 { |
|
1251 iLog->Log(_L("CMPXCollectionPlaylist::CMPXCollectionOpenUtilitySetDirection does not work right")); |
|
1252 delete utility; |
|
1253 utility = NULL; |
|
1254 return err; |
|
1255 } |
|
1256 delete utility; |
|
1257 utility = NULL; |
|
1258 iLog->Log(_L("CMPXCollectionPlaylist::CMPXCollectionOpenUtilitySetDirection return err: %d"),err); |
|
1259 return err; |
|
1260 } |
|
1261 |
|
1262 |
|
1263 // --------------------------------------------------------------------------- |
|
1264 // CMPXCollectionPlaylistTest::NewLMMPXCollectionUtility |
|
1265 // ?implementation_description |
|
1266 // (other items were commented in a header). |
|
1267 // --------------------------------------------------------------------------- |
|
1268 // |
|
1269 TInt CMPXCollectionPlaylistTest::NewLMMPXCollectionUtility( CStifItemParser& /*aItem*/) |
|
1270 { |
|
1271 iLog->Log(_L("CMPXCollectionPlaylistTest::NewLMMPXCollectionUtility")); |
|
1272 TInt err = KErrNone; |
|
1273 TRAP( err,iCollectionPlaylist = CMPXCollectionPlaylist::NewL()); |
|
1274 MMPXCollectionUtility* collectionUtility; |
|
1275 TRAP( err , collectionUtility = MMPXCollectionUtility::NewL(iCollectionPlaylist,KMcModeDefault)); |
|
1276 collectionUtility->Close(); |
|
1277 iLog->Log(_L("CMPXCollectionPlaylist::NewLMMPXCollectionUtility OK")); |
|
1278 return err; |
|
1279 } |
|
1280 |