|
1 /* |
|
2 * Copyright (c) 2006 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: Controls playback via plug-ins |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #ifndef CMPXPLAYBACKENGINE_H |
|
21 #define CMPXPLAYBACKENGINE_H |
|
22 |
|
23 |
|
24 #include <bamdesca.h> |
|
25 #include <badesca.h> |
|
26 // |
|
27 #include <mpxcenrepobserver.h> |
|
28 #include <mpxplaybackframeworkdefs.h> |
|
29 #include <mpxplaybackmessage.h> |
|
30 #include <mpxplaybackplugin.h> |
|
31 #include <mpxplaybackpluginobserver.h> |
|
32 #include <mpxpluginhandlerobserver.h> |
|
33 #include <mpxclientlist.h> |
|
34 #include <mpxtaskqueue.h> |
|
35 #include <mpxtaskqueueobserver.h> |
|
36 #include <mpxcollectionobserver.h> |
|
37 #include <mpxcollectionplaylistobserver.h> |
|
38 #include <mpxcommand.h> |
|
39 #include <mpxcollectionplaylist.h> |
|
40 #include <mpxmessagequeue.h> |
|
41 #include <mpxsubscription.h> |
|
42 |
|
43 #include "mpxplaybackpluginhandler.h" |
|
44 #include "mpxplaybackcommandbufferobserver.h" |
|
45 #include "mpxaccessoryobserver.h" |
|
46 #include "mpxplaybacksettings.h" |
|
47 |
|
48 class CMPXPluginMonitor; |
|
49 class CMPXPlaybackPluginHandler; |
|
50 class CMPXAutoResumeHandler; |
|
51 class CMPXPlaybackCmdBuffer; |
|
52 class CMPXCollectionPlaylist; |
|
53 class MMPXPlaybackActiveEngineObserver; |
|
54 class CMPXActiveTaskQueue; |
|
55 class CMPXPlaybackInitializer; |
|
56 class CMPXPlaybackMediaHelper; |
|
57 class CMPXPlaybackDummyMediaObserver; |
|
58 |
|
59 // Constants |
|
60 _LIT(KMPXPlaybackPluginVersion2, "MPXPlaybackPluginVersion2"); |
|
61 /** |
|
62 * The playback 'engine' which delegates to plug-ins (or 'players'). Unless |
|
63 * stated otherwise, methods apply to currently loaded plug-in (player) and |
|
64 * currently initialised song. |
|
65 */ |
|
66 class CMPXPlaybackEngine : public CBase, |
|
67 public MMPXPlaybackPluginObserver, |
|
68 public MMPXPlaybackCmdBufferObserver, |
|
69 public MBeating, |
|
70 public MMPXAccessoryEventObserver, |
|
71 public MMPXTaskQueueObserver, |
|
72 public MMPXCollectionMediaObserver, |
|
73 public MMPXCollectionPlaylistObserver, |
|
74 public MMPXPluginHandlerObserver |
|
75 { |
|
76 public: |
|
77 |
|
78 /** |
|
79 * Two-phased constructor. |
|
80 * |
|
81 * @param aPluginMonitor plugin monitor |
|
82 * @param aObserver engine observer |
|
83 * @param aClientListObserver client list observer |
|
84 * @param aModeId denotes whether this player is designated for the |
|
85 * stand-alone application |
|
86 * @return Constructed object |
|
87 */ |
|
88 IMPORT_C static CMPXPlaybackEngine* NewL( |
|
89 CMPXPluginMonitor& aPluginMonitor, |
|
90 MMPXPlaybackActiveEngineObserver& aObserver, |
|
91 MMPXClientlistObserver* aClientListObserver, |
|
92 const TUid& aModeId); |
|
93 |
|
94 |
|
95 /** |
|
96 * Two-phased constructor. |
|
97 * |
|
98 * @param aPluginMonitor plugin monitor |
|
99 * @param aObserver engine observer |
|
100 * @param aClientListObserver client list observer |
|
101 * @param aModeId denotes whether this player is designated for the |
|
102 * stand-alone application |
|
103 * @param aCategory category of engine (Music, Video) |
|
104 * @return Constructed object |
|
105 */ |
|
106 IMPORT_C static CMPXPlaybackEngine* NewL( |
|
107 CMPXPluginMonitor& aPluginMonitor, |
|
108 MMPXPlaybackActiveEngineObserver& aObserver, |
|
109 MMPXClientlistObserver* aClientListObserver, |
|
110 const TUid& aModeId, |
|
111 const TInt aCategory); |
|
112 |
|
113 |
|
114 /** |
|
115 * Destructor |
|
116 */ |
|
117 IMPORT_C ~CMPXPlaybackEngine(); |
|
118 |
|
119 public: |
|
120 |
|
121 /** |
|
122 * Returns reference to client list |
|
123 * |
|
124 * @return client list object |
|
125 */ |
|
126 inline CMPXClientList* ClientList(); |
|
127 |
|
128 /** |
|
129 * Returns object encapsulating list of clients and its management |
|
130 * |
|
131 * @return playback plugin handler |
|
132 */ |
|
133 inline CMPXPlaybackPluginHandler* PluginHandler(); |
|
134 |
|
135 /** |
|
136 * Does this player (i.e. the currently loaded plug-in) have access to |
|
137 * audio resources |
|
138 * |
|
139 * @return ETrue audio resource is used by the player |
|
140 */ |
|
141 inline TBool IsPlayerActive() const; |
|
142 |
|
143 /** |
|
144 * Return mode id of this engine |
|
145 * |
|
146 * @return mode id |
|
147 */ |
|
148 inline const TUid& ModeId() const; |
|
149 |
|
150 |
|
151 /** |
|
152 * Return category of this engine |
|
153 * |
|
154 * @return category |
|
155 */ |
|
156 |
|
157 inline const TInt Category() const; |
|
158 |
|
159 |
|
160 /** |
|
161 * Current state |
|
162 * |
|
163 * @return playback state |
|
164 */ |
|
165 inline TMPXPlaybackState State() const; |
|
166 |
|
167 /** |
|
168 * Current collection path, or NULL if none (i.e. not from collection) |
|
169 */ |
|
170 inline const CMPXCollectionPlaylist* Playlist() const; |
|
171 |
|
172 /** |
|
173 * Current song index, or KErrNotFound if none (i.e. not from collection) |
|
174 */ |
|
175 inline TInt SongIndex() const; |
|
176 |
|
177 /** |
|
178 * Current uri, or KNullDesC if none (i.e. uri not supplied) |
|
179 */ |
|
180 inline const TDesC& Uri() const; |
|
181 |
|
182 /** |
|
183 * Current file handle |
|
184 */ |
|
185 inline const RFile& File() const; |
|
186 |
|
187 /** |
|
188 * Retursn last active process id |
|
189 * |
|
190 * @return process id of last active process |
|
191 */ |
|
192 inline TProcessId LastActiveProcessId() const; |
|
193 |
|
194 /** |
|
195 * Retursn last inactive process id |
|
196 * |
|
197 * @return process id of last inactive process |
|
198 */ |
|
199 inline TProcessId LastInactiveProcessId() const; |
|
200 |
|
201 /** |
|
202 * Initializes the player with a song in the collection |
|
203 * |
|
204 * @param aCollectionPath collection path |
|
205 * @param aPlay Whether to initialize for playback, or |
|
206 * else just to setup the engine first |
|
207 */ |
|
208 IMPORT_C void InitL( const CMPXCollectionPlaylist& aPlaylist, |
|
209 TBool aPlay ); |
|
210 |
|
211 /** |
|
212 * Initializes the player with a uri - doesn't use collection |
|
213 * |
|
214 * @param aUri URI of the song |
|
215 * @param aType the type of song |
|
216 */ |
|
217 IMPORT_C void InitL(const TDesC& aUri,const TDesC8& aType); |
|
218 |
|
219 /** |
|
220 * Initializes the player with a file - doesn't use collection |
|
221 * |
|
222 * @aFile file handle |
|
223 */ |
|
224 IMPORT_C void InitL(const RFile& aFile); |
|
225 |
|
226 /** |
|
227 * Initializes the player with a uri and Access Point |
|
228 * |
|
229 * @since S60 9.2 |
|
230 * @param aUri URI of the item |
|
231 * @param aType the mime type of the item |
|
232 * @param aAccessPoint the access point of the item |
|
233 */ |
|
234 IMPORT_C void InitStreamingL(const TDesC& aUri, const TDesC8& aType, const TInt aAccessPoint); |
|
235 |
|
236 /** |
|
237 * Initializes the player with a file and access point |
|
238 * |
|
239 * @since S60 9.2 |
|
240 * @param aFile file handle |
|
241 * @param aAccessPoint the access point of the item |
|
242 */ |
|
243 IMPORT_C void InitStreamingL(const RFile& aFile, const TInt aAccessPoint); |
|
244 |
|
245 /** |
|
246 * Cancel all outstanding, asynchronous requests |
|
247 */ |
|
248 IMPORT_C void CancelRequests(); |
|
249 |
|
250 /** |
|
251 * Issue a playback command |
|
252 * |
|
253 * @param aCmd playback command |
|
254 * @param aData optional data |
|
255 */ |
|
256 IMPORT_C void CommandL(TMPXPlaybackCommand aCmd,TInt aData=0); |
|
257 |
|
258 /** |
|
259 * Issue a playback command |
|
260 * |
|
261 * @param aCmd playback command |
|
262 * @param aMsgQueue Message Queue for the client |
|
263 */ |
|
264 IMPORT_C void CommandL(CMPXCommand& aCmd, const CMPXMessageQueue& aMsgQueue); |
|
265 |
|
266 /** |
|
267 * Sets the property value. Value not set until a property changed event is |
|
268 * returned to the client |
|
269 */ |
|
270 IMPORT_C void SetL(TMPXPlaybackProperty aProperty,TInt aValue); |
|
271 |
|
272 /** |
|
273 * Asynchronously retrieves the value of a property. Result will be called |
|
274 * back by using MMPXPlaybackEngineObserver |
|
275 */ |
|
276 IMPORT_C void PropertyL(TMPXPlaybackProperty aProperty, |
|
277 MMPXPlaybackEngineObserver& aCallback); |
|
278 |
|
279 /** |
|
280 * DEPRECATED |
|
281 * |
|
282 * Asynchronously return media properties |
|
283 * using MMPXPlaybackEngineObserver |
|
284 * |
|
285 * @param aCallback playback callback |
|
286 * @param aBuf parameter buffer, take over the ownership |
|
287 */ |
|
288 IMPORT_C void MediaL(MMPXPlaybackEngineObserver& aCallback, CBufBase* aBuf); |
|
289 |
|
290 /** |
|
291 * Asynchronously return media properties |
|
292 * using MMPXPlaybackEngineObserver |
|
293 * |
|
294 * @param aCallback playback callback |
|
295 * @param aCmd Command object containing attribute spec and attribute array |
|
296 */ |
|
297 IMPORT_C void MediaL(MMPXPlaybackEngineObserver& aCallback, const CMPXCommand& aCmd); |
|
298 |
|
299 /** |
|
300 * Asynchronously retrieves the sub player names. See MMPXPlayerManager |
|
301 * |
|
302 * @param aCallback playback callback |
|
303 */ |
|
304 IMPORT_C void SubPlayerNamesL(TUid aPlayerUid, |
|
305 MMPXPlaybackEngineObserver& aCallback); |
|
306 |
|
307 /** |
|
308 * Gets media from the plugin |
|
309 * |
|
310 * @param aCallback Callback method to call after retrieving media |
|
311 * @param aCmd Command containing the media attributes and attribute specs. |
|
312 * Ownership transfered |
|
313 */ |
|
314 void MediaFromPluginL( MMPXPlaybackEngineObserver* aCallback, |
|
315 CMPXCommand* aCmd ); |
|
316 |
|
317 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
318 /** |
|
319 * Current file handle |
|
320 */ |
|
321 inline const RFile64& File64() const; |
|
322 |
|
323 /** |
|
324 * Initializes the player with a file - doesn't use collection |
|
325 * |
|
326 * @aFile file handle |
|
327 */ |
|
328 IMPORT_C void Init64L(const RFile64& aFile); |
|
329 |
|
330 /** |
|
331 * Initializes the player with a file and access point |
|
332 * |
|
333 * @since S60 9.2 |
|
334 * @param aFile file handle |
|
335 * @param aAccessPoint the access point of the item |
|
336 */ |
|
337 IMPORT_C void InitStreaming64L(const RFile64& aFile, const TInt aAccessPoint); |
|
338 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
339 |
|
340 public: |
|
341 |
|
342 /** |
|
343 * Handle command |
|
344 * |
|
345 * @param aCmd command |
|
346 */ |
|
347 void HandleCommandL(TMPXPlaybackCommand aCmd, TInt aData=0); |
|
348 |
|
349 private: |
|
350 enum TPlaySource |
|
351 { |
|
352 EPlayNone, |
|
353 EPlayFromCollection, |
|
354 EPlayFromUri, |
|
355 EPlayFromFile, |
|
356 EPlayFromFile64 |
|
357 }; |
|
358 |
|
359 enum TAsyncRequest |
|
360 { |
|
361 EProperty, |
|
362 EMedia, |
|
363 ESubPlayerNames, |
|
364 EHandleNext |
|
365 }; |
|
366 |
|
367 /** |
|
368 * Helper class to reflect playback call back to engine itself. |
|
369 */ |
|
370 class TCallbackReflector : public MMPXPlaybackEngineObserver |
|
371 { |
|
372 public: |
|
373 |
|
374 /** |
|
375 * Contructor |
|
376 * |
|
377 * @param aEngine playback engine |
|
378 */ |
|
379 inline TCallbackReflector(CMPXPlaybackEngine& aEngine); |
|
380 |
|
381 /** |
|
382 * From MMPXPlaybackEngineObserver |
|
383 * Handle playback property |
|
384 * |
|
385 * @param aProperty the property |
|
386 * @param aValue the value of the property |
|
387 * @param aError error code |
|
388 */ |
|
389 inline void HandleProperty(TMPXPlaybackProperty aProperty, |
|
390 TInt aValue, |
|
391 TInt aError); |
|
392 |
|
393 /** |
|
394 * From MMPXPlaybackEngineObserver |
|
395 * Method is called continously until aComplete=ETrue, signifying that |
|
396 * it is done and there will be no more callbacks |
|
397 * Only new items are passed each time |
|
398 * |
|
399 * @param aPlayer UID of the subplayer |
|
400 * @param aSubPlayers a list of sub players |
|
401 * @param aComplete ETrue no more sub players. EFalse more subplayer |
|
402 * expected |
|
403 * @param aError error code |
|
404 */ |
|
405 inline void HandleSubPlayerNames(TUid aPlayer, |
|
406 const MDesCArray* aSubPlayers, |
|
407 TBool aComplete, |
|
408 TInt aError); |
|
409 |
|
410 /** |
|
411 * From MMPXPlaybackEngineObserver |
|
412 * Handle media object |
|
413 * |
|
414 * @param aMedia media object |
|
415 * @param aError error code |
|
416 */ |
|
417 inline void HandleMedia(CMPXMedia* aMedia, TInt aError); |
|
418 |
|
419 private: |
|
420 CMPXPlaybackEngine& iEngine; |
|
421 }; |
|
422 |
|
423 private: |
|
424 |
|
425 /** |
|
426 * C++ constructor |
|
427 * |
|
428 * @param aPluginMonitor plugin monitor |
|
429 * @param aObserver engine observer |
|
430 * @param aModeId player engine mode |
|
431 */ |
|
432 CMPXPlaybackEngine(CMPXPluginMonitor& aPluginMonitor, |
|
433 MMPXPlaybackActiveEngineObserver& aObserver, |
|
434 const TUid& aModeId); |
|
435 |
|
436 |
|
437 /** |
|
438 * C++ constructor |
|
439 * |
|
440 * @param aPluginMonitor plugin monitor |
|
441 * @param aObserver engine observer |
|
442 * @param aModeId player engine mode |
|
443 * @param aCategory player engine category |
|
444 */ |
|
445 |
|
446 CMPXPlaybackEngine(CMPXPluginMonitor& aPluginMonitor, |
|
447 MMPXPlaybackActiveEngineObserver& aObserver, |
|
448 const TUid& aModeId, |
|
449 const TInt aCategory); |
|
450 |
|
451 |
|
452 /** |
|
453 * 2nd phase contructor |
|
454 * |
|
455 * @param aClientListObserver client list observer |
|
456 */ |
|
457 void ConstructL(MMPXClientlistObserver* aClientListObserver); |
|
458 |
|
459 |
|
460 private: // Functions from base class |
|
461 |
|
462 /** |
|
463 * From MBeating |
|
464 * Handles a regular heartbeat timer event |
|
465 */ |
|
466 void Beat(); |
|
467 |
|
468 /** |
|
469 * From MBeating |
|
470 * Synchronises the heartbeat timer with system clock |
|
471 */ |
|
472 void Synchronize(); |
|
473 |
|
474 /** |
|
475 * From MMPXPlayerAccessoryEventObserver |
|
476 * Handle accessory event |
|
477 * |
|
478 * @param aMode playback accessory mode |
|
479 */ |
|
480 void HandleAccesoryEventL(TMPXPlaybackAccessoryMode aMode); |
|
481 |
|
482 /** |
|
483 * From MMPXPlaybackPluginObserver |
|
484 * Handle plugin event |
|
485 * |
|
486 * @param aEvent the event type |
|
487 * @param aData optional data |
|
488 * @param aError error code of the event |
|
489 */ |
|
490 void HandlePluginEvent(TEvent aEvent,TInt aData,TInt aError); |
|
491 |
|
492 /** |
|
493 * From MMPXPlaybackPluginObserver |
|
494 * Handle message from plug-in |
|
495 * |
|
496 * @param aMsg, message from the plug-in. Ownership not transferred. |
|
497 * @param aErr system error code. if aErr is not KErrNone, aMsg will not be |
|
498 * used/dereferenced at playback engine. |
|
499 */ |
|
500 void HandlePlaybackMessage(CMPXMessage* aMsg, TInt aErr); |
|
501 |
|
502 /** |
|
503 * From MMPXPlaybackPluginObserver |
|
504 * Async response for Value request |
|
505 * |
|
506 * @param aProperty property key |
|
507 * @param aValue property value |
|
508 * @param aError error code |
|
509 */ |
|
510 void HandleProperty(TMPXPlaybackProperty aProperty, |
|
511 TInt aValue, TInt aError); |
|
512 |
|
513 /** |
|
514 * From MMPXPlaybackPluginObserver |
|
515 * Async response for MediaL request |
|
516 * |
|
517 * @param aMedia media object |
|
518 * @param aError error code |
|
519 */ |
|
520 void HandleMedia(CMPXMedia* aMedia, TInt aError); |
|
521 |
|
522 /** |
|
523 * From MMPXPlaybackPluginObserver |
|
524 * Async response for subplayer request |
|
525 * |
|
526 * @param aPlayer UID of the subplayer |
|
527 * @param aSubPlayers array of subplayers |
|
528 * @param aComplete ETrue, completed, EFalse, not completed |
|
529 * @param aError error code |
|
530 */ |
|
531 void HandleSubPlayerNames(TUid aPlayer, const MDesCArray* aSubPlayers, |
|
532 TBool aComplete, TInt aError); |
|
533 |
|
534 /** |
|
535 * From MMPXPlaybackCmdBufferObserver |
|
536 * Handle command from buffering |
|
537 * |
|
538 * @param aEvent comand info |
|
539 */ |
|
540 void HandleCmdBufferEventL(const TMPXPlaybackCmdInfo& aEvent); |
|
541 |
|
542 /** |
|
543 * From MMPXPlaybackCmdBufferObserver |
|
544 * Handle command skip event from key buffering |
|
545 * |
|
546 * @param aSkipEvent Skip event |
|
547 */ |
|
548 void HandleCmdBufferSkipEventL(const TMPXPlaybackSkipEvent aSkipEvent); |
|
549 |
|
550 /////////////////////////////////////////////////////////////////////////// |
|
551 // From MMPXTaskQueueObserver |
|
552 |
|
553 /** |
|
554 * Execute a task |
|
555 * @param aTask task number |
|
556 * @param aParamData, parameter |
|
557 * @param aPtrData, any object |
|
558 * @param aBuf, buffer containing externalized parameters for the task. |
|
559 * @param aCallback call back function pointer |
|
560 * @param aCObject1 object 1 owned by task queue |
|
561 * @param aCObject2 object 2 owned by task queue |
|
562 */ |
|
563 void ExecuteTask(TInt aTask, |
|
564 TInt aParamData, |
|
565 TAny* aPtrData, |
|
566 const CBufBase& aBuf, |
|
567 TAny* aCallback, |
|
568 CBase* aCObject1, |
|
569 CBase* aCObject2); |
|
570 |
|
571 /** |
|
572 * From MMPXCollectionMediaObserver |
|
573 * Handle media properties from collection |
|
574 * |
|
575 * @param aMedia media |
|
576 * @param aError error code |
|
577 */ |
|
578 void HandleCollectionMediaL(const CMPXMedia& aProperties, TInt aError); |
|
579 |
|
580 /** |
|
581 * From MMPXCollectionPlaylistObserver |
|
582 * Handle collection playlist change |
|
583 * |
|
584 * @param aError KErrNotFound - Playlist is updated, current item removed |
|
585 * KErrNone - Playlist is updated, current item is valid |
|
586 * KErrEof - Playlist is updated, current item removed and |
|
587 * reached to the end of playlist |
|
588 */ |
|
589 void HandleCollectionPlaylistChange(TInt aError); |
|
590 |
|
591 /////////////////////////////////////////////////////////////////////////// |
|
592 // From MMPXPluginHandlerObserver |
|
593 |
|
594 /* |
|
595 * @see MMPXPluginHandlerObserver |
|
596 */ |
|
597 void HandlePluginHandlerEvent(TPluginHandlerEvents aEvent, const TUid& aPluginUid, |
|
598 TBool aLoaded, TInt aData); |
|
599 |
|
600 private: // New functions |
|
601 |
|
602 |
|
603 /** |
|
604 * Return current plugin |
|
605 * |
|
606 * @return plugin object |
|
607 */ |
|
608 inline CMPXPlaybackPlugin* PluginL() const; |
|
609 |
|
610 /** |
|
611 * Suspend playback |
|
612 */ |
|
613 void Suspend(); |
|
614 |
|
615 /** |
|
616 * Seek timer tick |
|
617 */ |
|
618 void SeekTimerTick(); |
|
619 |
|
620 /** |
|
621 * Seek timer callback |
|
622 * |
|
623 * @param aPtr pointer the this |
|
624 */ |
|
625 static TInt SeekTimerCallback(TAny* aPtr); |
|
626 |
|
627 /** |
|
628 * Init plugin |
|
629 * |
|
630 * @param aSong, song path |
|
631 * @param aType, song type |
|
632 * @param aFile, file handle |
|
633 * @param aAccessPoint aAccessPoint |
|
634 */ |
|
635 void InitL(const TDesC* aSong,const TDesC8* aType,RFile* aFile, |
|
636 TInt aAccessPoint=0); |
|
637 |
|
638 /** |
|
639 * Handle play command |
|
640 */ |
|
641 void HandlePlayL(); |
|
642 |
|
643 /** |
|
644 * Handle play command with fade in |
|
645 */ |
|
646 void HandlePlayWithFadeInL(); |
|
647 |
|
648 /** |
|
649 * Handle pause command |
|
650 */ |
|
651 void HandlePauseL(); |
|
652 |
|
653 /** |
|
654 * Handle stop command |
|
655 */ |
|
656 void HandleStopL(); |
|
657 |
|
658 /** |
|
659 * Stop play back |
|
660 * @param aSavePlaybackInfo flag to determine if the PlaybackInfo should be saved |
|
661 */ |
|
662 void DoStopL(TBool aSavePlaybackInfo = ETrue); |
|
663 |
|
664 /** |
|
665 * Handle next command |
|
666 * @param aOffset offset to current index |
|
667 * @param aIgnoreRepeat ETrue to ignore repeat setting |
|
668 */ |
|
669 void HandleNextL( TInt aOffset = 1, TBool aIgnoreRepeat=EFalse ); |
|
670 |
|
671 /** |
|
672 * Handle previous command |
|
673 * @param aOffset offset to current index |
|
674 * @param aIgnoreRepeat ETrue to ignore repeat setting |
|
675 */ |
|
676 void HandlePreviousL(TInt aOffset = -1, TBool aIgnoreRepeat=EFalse ); |
|
677 |
|
678 /** |
|
679 * Handle replay command |
|
680 */ |
|
681 void HandleReplayL(); |
|
682 |
|
683 /** |
|
684 * Handle sart seekingcommand |
|
685 */ |
|
686 void HandleStartSeekL(TBool aForward); |
|
687 |
|
688 /** |
|
689 * Handle stop seeking command |
|
690 */ |
|
691 void HandleStopSeekingL(); |
|
692 |
|
693 /** |
|
694 * Handle increase volume command |
|
695 */ |
|
696 void HandleIncreaseVolumeL(); |
|
697 |
|
698 /** |
|
699 * Handle decrease volume command |
|
700 */ |
|
701 void HandleDecreaseVolumeL(); |
|
702 |
|
703 /** |
|
704 * Handle set volume command |
|
705 */ |
|
706 void HandleSetVolumeL(TInt aVolume); |
|
707 |
|
708 /** |
|
709 * Handle mute command |
|
710 */ |
|
711 void HandleMuteL(TBool aMute); |
|
712 |
|
713 /** |
|
714 * Handle close command |
|
715 * @param aData data to be forwarded to the player |
|
716 */ |
|
717 void HandleCloseL( TInt aData = KErrNone ); |
|
718 |
|
719 /** |
|
720 * Handle a custom command |
|
721 */ |
|
722 void HandleEffectL(TInt aData); |
|
723 |
|
724 /** |
|
725 * Handle a custom command |
|
726 */ |
|
727 void HandleDisableEffectL(); |
|
728 |
|
729 /** |
|
730 * Handle a request to close the file handle for an item |
|
731 * @param aItemId item that is requested to be freed |
|
732 */ |
|
733 void HandleCloseItemL( TInt aItemId ); |
|
734 |
|
735 /** |
|
736 * Sets the current properties for the plug-in |
|
737 */ |
|
738 void SetPropertiesL(); |
|
739 |
|
740 /** |
|
741 * Stop seeking timer |
|
742 */ |
|
743 void EndSeek(); |
|
744 |
|
745 /** |
|
746 * Set a playback state |
|
747 * @param aState new state |
|
748 */ |
|
749 void SetStateL(TMPXPlaybackState aState); |
|
750 |
|
751 /** |
|
752 * Set a playback state, takes in a TMPXPlaybackMessage with the |
|
753 * state already set as the iType parameter. This Allows caller to |
|
754 * set iData information as well. |
|
755 * @param aMessage Message containing state information |
|
756 */ |
|
757 void SetStateL( TMPXPlaybackMessage& aMsg ); |
|
758 |
|
759 /** |
|
760 * Set player activated |
|
761 * @param aActive ETrue actived, EFalse inactived. |
|
762 */ |
|
763 void SetPlayerActivated(TBool aActive); |
|
764 |
|
765 /** |
|
766 * Execute a task |
|
767 * @param aTask task number |
|
768 * @param aParamData, parameter |
|
769 * @param aPtrData, any object |
|
770 * @param aCallback call back function pointer |
|
771 * @param aBuf buffer data |
|
772 * @param aCObject1 object 1 owned by task queue |
|
773 * @param aCObject2 object 2 owned by task queue |
|
774 */ |
|
775 void ExecuteTaskL(TInt aTask, |
|
776 TInt aParamData, |
|
777 TAny* aPtrData, |
|
778 TAny* aCallback, |
|
779 const CBufBase& aBuf, |
|
780 CBase* aCObject1, |
|
781 CBase* aCObject2); |
|
782 |
|
783 /** |
|
784 * @see MMPXTaskQueueObserver |
|
785 */ |
|
786 void HandleTaskError(TInt aTask, |
|
787 TAny* aPtrData, |
|
788 TAny* aCallback, |
|
789 TInt aError); |
|
790 |
|
791 /** |
|
792 * Handle error of execution |
|
793 * @param aTask task number |
|
794 * @param aErr error number |
|
795 * @param aParamData parameter |
|
796 */ |
|
797 void HandleError(TInt aTask, TInt aErr, TInt aParamData = 0); |
|
798 |
|
799 /** |
|
800 * Get command from state |
|
801 */ |
|
802 TMPXPlaybackCommand CommandFromState( TMPXPlaybackState aState ); |
|
803 |
|
804 /** |
|
805 * Cleanup when the engine closed |
|
806 */ |
|
807 void DoClose(); |
|
808 |
|
809 /** |
|
810 * Media request from collection |
|
811 */ |
|
812 void MediaFromCollectionL(); |
|
813 |
|
814 /** |
|
815 * Handle plugin event |
|
816 * |
|
817 * @param aEvent the event type |
|
818 * @param aData optional data |
|
819 * @param aError error code of the event |
|
820 */ |
|
821 void DoHandlePluginEventL(TEvent aEvent,TInt aData,TInt aError); |
|
822 |
|
823 /** |
|
824 * Update playbackengine state machine |
|
825 * Handles plugin events that could cause state change in playback-engine |
|
826 * |
|
827 * @param aEvent the event type |
|
828 * @param aData optional data |
|
829 * @param aError error code of the event |
|
830 */ |
|
831 void UpdateStateMachineL(TEvent aEvent,TInt aData,TInt aError); |
|
832 |
|
833 /* |
|
834 * Handle plugin event error handling |
|
835 * This is internal function called from DoHandlePluginEvent() |
|
836 * @param aEvent the event type |
|
837 * @param aError error code of the event |
|
838 */ |
|
839 void HandlePluginEventErrorHandling(TEvent aEvent, TInt aError); |
|
840 |
|
841 /* |
|
842 * Handle Plugin Event: Initialised |
|
843 * Handles the event called Initialised |
|
844 * @param aState the mpx playbackstate |
|
845 * @param aData data passed from playback plugin in call to HandlePluginEvent |
|
846 */ |
|
847 void HandlePluginEventInitialisedL(TMPXPlaybackState& aState, TInt aData); |
|
848 |
|
849 /** |
|
850 * Save playback Information |
|
851 */ |
|
852 void SavePlaybackInfoL(); |
|
853 |
|
854 /** |
|
855 * Increments play count |
|
856 */ |
|
857 void SavePlaybackCompleteInfoL(); |
|
858 |
|
859 /** |
|
860 * Restore playback position and state if it was saved previously |
|
861 */ |
|
862 void RestorePlaybackPositionAndStateL( const CMPXMedia& aMedia ); |
|
863 |
|
864 /** |
|
865 * Sets the volume increment depending on accessory state |
|
866 */ |
|
867 void SetVolumeIncrement( TMPXPlaybackAccessoryMode aMode ); |
|
868 |
|
869 /** |
|
870 * Marks the current item as corrupted |
|
871 * @param aCorrupted Flag if corrupted or not |
|
872 */ |
|
873 void MarkItemCorrupted( const TBool aCorrupted ); |
|
874 |
|
875 /** |
|
876 * Marks the current item as invalid |
|
877 * @param aInvalid Flag if invalid or not |
|
878 */ |
|
879 void MarkItemInvalid( const TBool aInvalid ); |
|
880 |
|
881 /** |
|
882 * Marks the current item as DRM invalid (e.g. no rights) |
|
883 * @param aDrmInvalid Flag if invalid or not |
|
884 */ |
|
885 void MarkItemDrmInvalid( const TBool aDrmInvalid ); |
|
886 |
|
887 /** |
|
888 * Sets flag bits |
|
889 * @aSet ETrue to set, EFalse to unset |
|
890 * @aFlag Flag bits to set/unset |
|
891 */ |
|
892 void SetFlagBitsL( const TBool aSet, const TUint aFlag ); |
|
893 |
|
894 /** |
|
895 * Creates a CMPXMedia object to be used to Set attributes |
|
896 * @param aPath Collection Path |
|
897 * @return CMPXMedia object |
|
898 */ |
|
899 CMPXMedia* CreateMediaToSetLC( const CMPXCollectionPath& aPath ); |
|
900 |
|
901 /** |
|
902 * Sends a request to iMediaHelper to request media |
|
903 */ |
|
904 void RequestMediaL(); |
|
905 |
|
906 /** |
|
907 * Sends a plugin handler message to all clients. |
|
908 * @param aMessageId the value of the KMPXMessageGeneralId attribute |
|
909 * @param aPluginUid plugin UID this message is for |
|
910 * @param aLoaded ETrue if the plugin is loaded |
|
911 * @param aVersion plugin version |
|
912 */ |
|
913 void SendPluginHandlerMessageL(TInt aMessageId, const TUid& aPluginUid, |
|
914 TBool aLoaded, TInt aVersion = 0); |
|
915 |
|
916 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
917 /** |
|
918 * Init plugin |
|
919 * |
|
920 * @param aSong, song path |
|
921 * @param aType, song type |
|
922 * @param aFile, file handle |
|
923 * @param aAccessPoint aAccessPoint |
|
924 */ |
|
925 void Init64L(RFile64* aFile, TInt aAccessPoint=0); |
|
926 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
927 |
|
928 private: |
|
929 friend class TCallbackReflector; |
|
930 friend class CMPXPlaybackInitializer; |
|
931 |
|
932 TCallbackReflector iReflector; |
|
933 CMPXPluginMonitor& iPluginMonitor; |
|
934 CMPXClientList* iClientList; |
|
935 CMPXPlaybackInitializer* iInitializer; |
|
936 CMPXPlaybackPluginHandler* iPluginHandler; |
|
937 TBool iInitNext; |
|
938 /** |
|
939 * Utilities |
|
940 */ |
|
941 CHeartbeat* iProgressTimer; |
|
942 CPeriodic* iSeekTimer; |
|
943 CMPXAccessoryObserver* iAccessoryObs; |
|
944 CMPXPlaybackCmdBuffer* iCmdBuffer; |
|
945 CMPXPlaybackSettings* iPlaybackSettings; |
|
946 CMPXAutoResumeHandler* iAutoResumeHandler; |
|
947 |
|
948 /** |
|
949 * Playlist/song data |
|
950 */ |
|
951 CMPXCollectionPlaylist* iPlaylist; |
|
952 HBufC* iUri; |
|
953 TMPXItemId iItemId; |
|
954 RFile iFile; |
|
955 TPlaySource iPlaySource; |
|
956 TUint iDbFlag; |
|
957 TInt iMediaDuration; // Duration value inside CMPXMedia |
|
958 |
|
959 TInt iAccessPoint; |
|
960 TBool iAccessPointSet; // Access Point is set |
|
961 |
|
962 /** |
|
963 * This player data |
|
964 */ |
|
965 TMPXPlaybackState iState; // current state |
|
966 TMPXPlaybackState iNextState; // next possible state when handling commands |
|
967 TMPXPlaybackState iPluginState; // plugin state |
|
968 TBool iEmbeddedMode; |
|
969 TUid iModeId; |
|
970 TInt iCategory; |
|
971 TBool iPlayerActive; |
|
972 // |
|
973 TFixedArray<TInt,EPbPropertyNum> iProperties; |
|
974 TInt iSeekStep; // millisecond |
|
975 TInt iMaxSeekStep; // millisecond |
|
976 MMPXPlaybackActiveEngineObserver& iObserver; |
|
977 CMPXActiveTaskQueue* iTaskQueue; |
|
978 MMPXPlaybackEngineObserver* iCallback; // Not owned. |
|
979 |
|
980 TMPXPlaybackState iPreservedState; |
|
981 TInt iPreservedPosition; |
|
982 |
|
983 TInt iVolumeIncrement; |
|
984 RArray<TMPXAttribute> iMediaAttrs; |
|
985 TBool iSkipping; |
|
986 CMPXPlaybackMediaHelper* iMediaHelper; |
|
987 |
|
988 CMPXPlaybackDummyMediaObserver* iDummyMediaObserver; |
|
989 TUid iPluginUid; // plugin uid for current item of current playlist |
|
990 TProcessId iLastActiveProcess; // Last active process for this engine |
|
991 TProcessId iLastInactiveProcess; // Last inactive process for this engine |
|
992 TBool iInitVolume; // Initialize volume on first creation |
|
993 // the index which be firstly saved when request media |
|
994 TInt iFirstRequestMediaIndex; |
|
995 #if defined(__HIGH_RESOLUTION_VOLUME) |
|
996 // flag to indicate whether the volume setting has been rounded up last |
|
997 // used to adjust volume up button setting |
|
998 TBool iVolRoundedUp; |
|
999 #endif |
|
1000 |
|
1001 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
1002 RFile64 iFile64; |
|
1003 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
1004 }; |
|
1005 |
|
1006 #include "mpxplaybackengine.inl" |
|
1007 |
|
1008 #endif // CMPXPLAYBACKENGINE_H |
|
1009 |