add iServiceKeys interface (No not what you think ;) it simply means its
[enigma2.git] / lib / service / iservice.h
1 #ifndef __lib_dvb_iservice_h
2 #define __lib_dvb_iservice_h
3
4 #include <lib/python/swig.h>
5 #include <lib/python/python.h>
6 #include <lib/base/object.h>
7 #include <string>
8 #include <connection.h>
9 #include <list>
10
11 class eServiceEvent;
12
13 class eServiceReference
14 {
15 public:
16         enum
17         {
18                 idInvalid=-1,
19                 idStructure,    // service_id == 0 is root
20                 idDVB,
21                 idFile,
22                 idUser=0x1000
23         };
24         int type;
25
26         enum
27         {
28                 isDirectory=1,          // SHOULD enter  (implies mustDescent)
29                 mustDescent=2,          // cannot be played directly - often used with "isDirectory" (implies canDescent)
30                 /*
31                         for example:
32                                 normal services have none of them - they can be fed directly into the "play"-handler.
33                                 normal directories have both of them set - you cannot play a directory directly and the UI should descent into it.
34                                 playlists have "mustDescent", but not "isDirectory" - you don't want the user to browse inside the playlist (unless he really wants)
35                                 services with sub-services have none of them, instead the have the "canDecsent" flag (as all of the above)
36                 */
37                 canDescent=4,                   // supports enterDirectory/leaveDirectory
38                 flagDirectory=isDirectory|mustDescent|canDescent,
39                 shouldSort=8,                   // should be ASCII-sorted according to service_name. great for directories.
40                 hasSortKey=16,          // has a sort key in data[3]. not having a sort key implies 0.
41                 sort1=32,                                       // sort key is 1 instead of 0
42                 isMarker=64,                    // Marker
43                 isGroup=128                     // is a group of services
44         };
45         int flags; // flags will NOT be compared.
46
47         inline int getSortKey() const { return (flags & hasSortKey) ? data[3] : ((flags & sort1) ? 1 : 0); }
48
49 #ifndef SWIG
50         int data[8];
51         std::string path;
52 #endif
53         std::string getPath() { return path; }
54         void setPath( const std::string &n ) { path=n; }
55
56         unsigned int getUnsignedData(unsigned int num) const
57         {
58                 if ( num < sizeof(data)/sizeof(int) )
59                         return data[num];
60                 return 0;
61         }
62
63         int getData(unsigned int num) const
64         {
65                 if ( num < sizeof(data)/sizeof(int) )
66                         return data[num];
67                 return 0;
68         }
69
70         void setUnsignedData(unsigned int num, unsigned int val)
71         {
72                 if ( num < sizeof(data)/sizeof(int) )
73                         data[num] = val;
74         }
75
76         void setData(unsigned int num, int val)
77         {
78                 if ( num < sizeof(data)/sizeof(int) )
79                         data[num] = val;
80         }
81
82 // only for override service names in bouquets or to give servicerefs a name which not have a
83 // real existing service ( for dvb eServiceDVB )
84 #ifndef SWIG
85         std::string name;
86 #endif
87         std::string getName() { return name; }
88         void setName( const std::string &n ) { name=n; }
89
90         eServiceReference()
91                 : type(idInvalid), flags(0)
92         {
93                 memset(data, 0, sizeof(data));
94         }
95 #ifndef SWIG
96         eServiceReference(int type, int flags)
97                 : type(type), flags(flags)
98         {
99                 memset(data, 0, sizeof(data));
100         }
101         eServiceReference(int type, int flags, int data0)
102                 : type(type), flags(flags)
103         {
104                 memset(data, 0, sizeof(data));
105                 data[0]=data0;
106         }
107         eServiceReference(int type, int flags, int data0, int data1)
108                 : type(type), flags(flags)
109         {
110                 memset(data, 0, sizeof(data));
111                 data[0]=data0;
112                 data[1]=data1;
113         }
114         eServiceReference(int type, int flags, int data0, int data1, int data2)
115                 : type(type), flags(flags)
116         {
117                 memset(data, 0, sizeof(data));
118                 data[0]=data0;
119                 data[1]=data1;
120                 data[2]=data2;
121         }
122         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
123                 : type(type), flags(flags)
124         {
125                 memset(data, 0, sizeof(data));
126                 data[0]=data0;
127                 data[1]=data1;
128                 data[2]=data2;
129                 data[3]=data3;
130         }
131         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
132                 : type(type), flags(flags)
133         {
134                 memset(data, 0, sizeof(data));
135                 data[0]=data0;
136                 data[1]=data1;
137                 data[2]=data2;
138                 data[3]=data3;
139                 data[4]=data4;
140         }
141 #endif
142         eServiceReference(int type, int flags, const std::string &path)
143                 : type(type), flags(flags), path(path)
144         {
145                 memset(data, 0, sizeof(data));
146         }
147         eServiceReference(const std::string &string);
148         std::string toString() const;
149         std::string toCompareString() const;
150         bool operator==(const eServiceReference &c) const
151         {
152                 if (type != c.type)
153                         return 0;
154                 return (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
155         }
156         bool operator!=(const eServiceReference &c) const
157         {
158                 return !(*this == c);
159         }
160         bool operator<(const eServiceReference &c) const
161         {
162                 if (type < c.type)
163                         return 1;
164
165                 if (type > c.type)
166                         return 0;
167
168                 int r=memcmp(data, c.data, sizeof(int)*8);
169                 if (r)
170                         return r < 0;
171                 return path < c.path;
172         }
173         operator bool() const
174         {
175                 return valid();
176         }
177         
178         int valid() const
179         {
180                 return type != idInvalid;
181         }
182 };
183
184 SWIG_ALLOW_OUTPUT_SIMPLE(eServiceReference);
185
186 extern PyObject *New_eServiceReference(const eServiceReference &ref); // defined in enigma_python.i
187
188 #ifndef SWIG
189 #ifdef PYTHON_REFCOUNT_DEBUG
190 inline ePyObject Impl_New_eServiceReference(const char* file, int line, const eServiceReference &ref)
191 {
192         return ePyObject(New_eServiceReference(ref), file, line);
193 }
194 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(__FILE__, __LINE__, ref)
195 #else
196 inline ePyObject Impl_New_eServiceReference(const eServiceReference &ref)
197 {
198         return New_eServiceReference(ref);
199 }
200 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(ref)
201 #endif
202 #endif // SWIG
203
204 typedef long long pts_t;
205
206         /* the reason we have the servicereference as additional argument is
207            that we don't have to create one object for every entry in a possibly
208            large list, provided that no state information is nessesary to deliver
209            the required information. Anyway - ref *must* be the same as the argument
210            to the info() or getIServiceInformation call! */
211
212         /* About the usage of SWIG_VOID:
213            SWIG_VOID(real_returntype_t) hides a return value from swig. This is used for
214            the "superflouus" RESULT return values.
215            
216            Python code has to check the returned pointer against 0. This works,
217            as all functions returning instances in smartpointers AND having a 
218            RESULT have to BOTH return non-zero AND set the pointer to zero.
219            
220            Python code thus can't check for the reason, but the reason isn't
221            user-servicable anyway. If you want to return a real reason which
222            goes beyong "it just doesn't work", use extra variables for this,
223            not the RESULT.
224            
225            Hide the result only if there is another way to check for failure! */
226            
227 class eServiceEvent;
228
229 SWIG_IGNORE(iStaticServiceInformation);
230 class iStaticServiceInformation: public iObject
231 {
232 #ifdef SWIG
233         iStaticServiceInformation();
234         ~iStaticServiceInformation();
235 #endif
236 public:
237         virtual SWIG_VOID(RESULT) getName(const eServiceReference &ref, std::string &SWIG_OUTPUT)=0;
238
239                 // doesn't need to be implemented, should return -1 then.
240         virtual int getLength(const eServiceReference &ref);
241         virtual SWIG_VOID(RESULT) getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time=-1);
242                 // returns true when not implemented
243         virtual int isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
244
245         virtual int getInfo(const eServiceReference &ref, int w);
246         virtual std::string getInfoString(const eServiceReference &ref,int w);
247         virtual PyObject *getInfoObject(const eServiceReference &ref, int w);
248
249         virtual int setInfo(const eServiceReference &ref, int w, int v);
250         virtual int setInfoString(const eServiceReference &ref, int w, const char *v);
251 };
252 SWIG_TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
253
254 class iServiceInformation_ENUMS
255 {
256 #ifdef SWIG
257         iServiceInformation_ENUMS();
258         ~iServiceInformation_ENUMS();
259 #endif
260 public:
261         enum {
262                 sIsCrypted,             /* is encrypted (no indication if decrypt was possible) */
263                 sAspect,                /* aspect ratio: 0=4:3, 1=16:9, 2=whatever we need */
264                 sIsMultichannel,        /* multichannel *available* (probably not selected) */
265
266                         /* "user serviceable info" - they are not reliable. Don't use them for anything except the service menu!
267                            that's also the reason why they are so globally defined.
268                            again - if somebody EVER tries to use this information for anything else than simply displaying it,
269                            i will change this to return a user-readable text like "zero x zero three three" (and change the
270                            exact spelling in every version) to stop that! */
271
272                 sVideoPID,
273                 sAudioPID,
274                 sPCRPID,
275                 sPMTPID,
276                 sTXTPID,
277
278                 sSID,
279                 sONID,
280                 sTSID,
281                 sNamespace,
282                 sProvider,
283
284                 sDescription,
285                 sServiceref,
286                 sTimeCreate,            /* unix time or string */
287
288                 sTitle,
289                 sArtist,
290                 sAlbum,
291                 sComment,
292                 sTracknumber,
293                 sGenre,
294                 sCAIDs,
295                 sVideoType,             /* MPEG2 MPEG4 */
296
297                 sTags,                          /* space seperated list of tags */
298
299                 sDVBState,                      /* states as defined in pmt handler (as events there) */
300
301                 sVideoHeight,
302                 sVideoWidth,
303
304                 sTransponderData        /* transponderdata as python dict */
305         };
306         enum {
307                 resNA = -1,
308                 resIsString = -2,
309                 resIsPyObject = -3
310         };
311 };
312
313 /* some words to structs like struct iServiceInformation_ENUMS
314 For some classes we need in python just the SmartPointer Variants.
315 So we prevent building wrapper classes for the non smart pointer classes with the SWIG_IGNORE makro.
316 But now we have the problem that swig do not export enums for smart pointer classes (i dont know why).
317 So we move all enum's to own classes (with _ENUMS as name ending) and let our real
318 class inherit from the *_ENUMS class. This *_ENUMS classes are normally exportet via swig to python.
319 But in the python code we doesn't like to write iServiceInformation_ENUMS.sVideoType....
320 we like to write iServiceInformation.sVideoType.
321 So until swig have no Solution for this Problem we call in lib/python/Makefile.am a python script named
322 enigma_py_patcher.py to remove the "_ENUMS" strings in enigma.py at all needed locations. */
323
324 SWIG_IGNORE(iServiceInformation);
325 class iServiceInformation: public iServiceInformation_ENUMS, public iObject
326 {
327 #ifdef SWIG
328         iServiceInformation();
329         ~iServiceInformation();
330 #endif
331 public:
332         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
333         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
334
335         virtual int getInfo(int w);
336         virtual std::string getInfoString(int w);
337         virtual PyObject *getInfoObject(int w);
338
339         virtual int setInfo(int w, int v);
340         virtual int setInfoString(int w, const char *v);
341 };
342 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
343
344 class iFrontendInformation_ENUMS
345 {
346 #ifdef SWIG
347         iFrontendInformation_ENUMS();
348         ~iFrontendInformation_ENUMS();
349 #endif
350 public:
351         enum {
352                 bitErrorRate,
353                 signalPower,
354                 signalQuality,
355                 lockState,
356                 syncState,
357                 frontendNumber,
358                 signalQualitydB,
359         };
360 };
361
362 SWIG_IGNORE(iFrontendInformation);
363 class iFrontendInformation: public iFrontendInformation_ENUMS, public iObject
364 {
365 #ifdef SWIG
366         iFrontendInformation();
367         ~iFrontendInformation();
368 #endif
369 public:
370         virtual int getFrontendInfo(int w)=0;
371         virtual PyObject *getFrontendData()=0;
372         virtual PyObject *getFrontendStatus()=0;
373         virtual PyObject *getTransponderData(bool original)=0;
374         virtual PyObject *getAll(bool original)=0; // a sum of getFrontendData/Status/TransponderData
375 };
376 SWIG_TEMPLATE_TYPEDEF(ePtr<iFrontendInformation>, iFrontendInformationPtr);
377
378 SWIG_IGNORE(iPauseableService);
379 class iPauseableService: public iObject
380 {
381 #ifdef SWIG
382         iPausableService();
383         ~iPausableService();
384 #endif
385 public:
386         virtual RESULT pause()=0;
387         virtual RESULT unpause()=0;
388
389                 /* hm. */
390         virtual RESULT setSlowMotion(int ratio=0)=0;
391         virtual RESULT setFastForward(int ratio=0)=0;
392 };
393 SWIG_TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
394
395 class iSeekableService_ENUMS
396 {
397 #ifdef SWIG
398         iSeekableService_ENUMS();
399         ~iSeekableService_ENUMS();
400 #endif
401 public:
402         enum { dirForward = +1, dirBackward = -1 };
403 };
404
405 SWIG_IGNORE(iSeekableService);
406 class iSeekableService: public iSeekableService_ENUMS, public iObject
407 {
408 #ifdef SWIG
409         iSeekableService();
410         ~iSeekableService();
411 #endif
412 public:
413         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
414         virtual RESULT seekTo(pts_t to)=0;
415         virtual RESULT seekRelative(int direction, pts_t to)=0;
416         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
417                 /* if you want to do several seeks in a row, you can enable the trickmode.
418                    audio will be switched off, sync will be disabled etc. */
419         virtual RESULT setTrickmode(int trick=0)=0;
420         virtual RESULT isCurrentlySeekable()=0;
421 };
422 SWIG_TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
423
424 struct iAudioTrackInfo
425 {
426 #ifndef SWIG
427         std::string m_description;
428         std::string m_language; /* iso639 */
429         int m_pid; /* for association with the stream. */
430 #endif
431         std::string getDescription() { return m_description; }
432         std::string getLanguage() { return m_language; }
433         int getPID() { return m_pid; }
434 };
435 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
436
437 SWIG_IGNORE(iAudioTrackSelection);
438 class iAudioTrackSelection: public iObject
439 {
440 #ifdef SWIG
441         iAudioTrackSelection();
442         ~iAudioTrackSelection();
443 #endif
444 public:
445         virtual int getNumberOfTracks()=0;
446         virtual RESULT selectTrack(unsigned int i)=0;
447         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
448         virtual int getCurrentTrack()=0;
449 };
450 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
451
452 class iAudioChannelSelection_ENUMS
453 {
454 #ifdef SWIG
455         iAudioChannelSelection_ENUMS();
456         ~iAudioChannelSelection_ENUMS();
457 #endif
458 public:
459         enum { LEFT, STEREO, RIGHT };
460 };
461
462 SWIG_IGNORE(iAudioChannelSelection);
463 class iAudioChannelSelection: public iAudioChannelSelection_ENUMS, public iObject
464 {
465 #ifdef SWIG
466         iAudioChannelSelection();
467         ~iAudioChannelSelection();
468 #endif
469 public:
470         virtual int getCurrentChannel()=0;
471         virtual RESULT selectChannel(int i)=0;
472 };
473 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
474
475 SWIG_IGNORE(iAudioDelay);
476 class iAudioDelay: public iObject
477 {
478 #ifdef SWIG
479         iAudioDelay();
480         ~iAudioDelay();
481 #endif
482 public:
483         virtual int getAC3Delay()=0;
484         virtual int getPCMDelay()=0;
485         virtual void setAC3Delay(int)=0;
486         virtual void setPCMDelay(int)=0;
487 };
488 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
489
490 class iRdsDecoder_ENUMS
491 {
492 #ifdef SWIG
493         iRdsDecoder_ENUMS();
494         ~iRdsDecoder_ENUMS();
495 #endif
496 public:
497         enum { RadioText, RtpText };
498 };
499
500 SWIG_IGNORE(iRdsDecoder);
501 class iRdsDecoder: public iObject, public iRdsDecoder_ENUMS
502 {
503 #ifdef SWIG
504         iRdsDecoder();
505         ~iRdsDecoder();
506 #endif
507 public:
508         virtual std::string getText(int x=RadioText)=0;
509         virtual void showRassSlidePicture()=0;
510         virtual void showRassInteractivePic(int page, int subpage)=0;
511         virtual SWIG_PYOBJECT(ePyObject) getRassInteractiveMask()=0;
512 };
513 SWIG_TEMPLATE_TYPEDEF(ePtr<iRdsDecoder>, iRdsDecoderPtr);
514
515 SWIG_IGNORE(iSubserviceList);
516 class iSubserviceList: public iObject
517 {
518 #ifdef SWIG
519         iSubserviceList();
520         ~iSubserviceList();
521 #endif
522 public:
523         virtual int getNumberOfSubservices()=0;
524         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
525 };
526 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
527
528 SWIG_IGNORE(iTimeshiftService);
529 class iTimeshiftService: public iObject
530 {
531 #ifdef SWIG
532         iTimeshiftService();
533         ~iTimeshiftService();
534 #endif
535 public:
536         virtual RESULT startTimeshift()=0;
537         virtual RESULT stopTimeshift()=0;
538
539         virtual int isTimeshiftActive()=0;
540                         /* this essentially seeks to the relative end of the timeshift buffer */
541         virtual RESULT activateTimeshift()=0;
542 };
543 SWIG_TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
544
545         /* not related to eCueSheet */
546
547 class iCueSheet_ENUMS
548 {
549 #ifdef SWIG
550         iCueSheet_ENUMS();
551         ~iCueSheet_ENUMS();
552 #endif
553 public:
554         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
555 };
556
557 SWIG_IGNORE(iCueSheet);
558 class iCueSheet: public iCueSheet_ENUMS, public iObject
559 {
560 #ifdef SWIG
561         iCueSheet();
562         ~iCueSheet();
563 #endif
564 public:
565         /* returns a list of (pts, what)-tuples */
566         virtual PyObject *getCutList() = 0;
567         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
568         virtual void setCutListEnable(int enable) = 0;
569 };
570 SWIG_TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
571
572 class eWidget;
573 class PyList;
574
575 SWIG_IGNORE(iSubtitleOutput);
576 class iSubtitleOutput: public iObject
577 {
578 public:
579         virtual RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry)=0;
580         virtual RESULT disableSubtitles(eWidget *parent)=0;
581         virtual PyObject *getSubtitleList()=0;
582         virtual PyObject *getCachedSubtitle()=0;
583 };
584 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
585
586 SWIG_IGNORE(iMutableServiceList);
587 class iMutableServiceList: public iObject
588 {
589 #ifdef SWIG
590         iMutableServiceList();
591         ~iMutableServiceList();
592 #endif
593 public:
594                 /* flush changes */
595         virtual RESULT flushChanges()=0;
596                 /* adds a service to a list */
597         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
598                 /* removes a service from a list */
599         virtual RESULT removeService(eServiceReference &ref)=0;
600                 /* moves a service in a list, only if list suppports a specific sort method. */
601                 /* pos is the new, absolute position from 0..size-1 */
602         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
603                 /* set name of list, for bouquets this is the visible bouquet name */
604         virtual RESULT setListName(const std::string &name)=0;
605 };
606 SWIG_TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
607
608 SWIG_IGNORE(iListableService);
609 class iListableService: public iObject
610 {
611 #ifdef SWIG
612         iListableService();
613         ~iListableService();
614 #endif
615 public:
616 #ifndef SWIG
617                 /* legacy interface: get a list */
618         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
619 #endif
620         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
621
622                 /* new, shiny interface: streaming. */
623         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
624
625                 /* use this for sorting. output is not sorted because of either
626                  - performance reasons: the whole list must be buffered or
627                  - the interface would be restricted to a list. streaming
628                    (as well as a future "active" extension) won't be possible.
629                 */
630         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
631
632         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
633 };
634 SWIG_TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
635
636 #ifndef SWIG
637         /* a helper class which can be used as argument to stl's sort(). */
638 class iListableServiceCompare
639 {
640         ePtr<iListableService> m_list;
641 public:
642         iListableServiceCompare(iListableService *list): m_list(list) { }
643         bool operator()(const eServiceReference &a, const eServiceReference &b)
644         {
645                 return m_list->compareLessEqual(a, b);
646         }
647 };
648 #endif
649
650 SWIG_IGNORE(iServiceOfflineOperations);
651 class iServiceOfflineOperations: public iObject
652 {
653 #ifdef SWIG
654         iServiceOfflineOperations();
655         ~iServiceOfflineOperations();
656 #endif
657 public:
658                 /* to delete a service, forever. */
659         virtual RESULT deleteFromDisk(int simulate=1)=0;
660
661                 /* for transferring a service... */
662         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
663
664                 // TODO: additional stuff, like a conversion interface?
665 };
666 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
667
668 SWIG_IGNORE(iStreamableService);
669 class iStreamableService: public iObject
670 {
671 #ifdef SWIG
672         iStreamableService();
673         ~iStreamableService();
674 #endif
675 public:
676                 /* returns a dict:
677                         { "demux": <n>,
678                           "pids": [(x,type),(y,type),(z,type),..],
679                           ...
680                         }
681                         with type being "video", "audio", "pmt", "pat"...
682                 */
683         virtual PyObject *getStreamingData()=0;
684 };
685 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamableService>, iStreamableServicePtr);
686
687 class iServiceKeys_ENUMS
688 {
689 #ifdef SWIG
690         iServiceKeys_ENUMS();
691         ~iServiceKeys_ENUMS();
692 #endif
693 public:
694         enum {
695                 keyLeft,
696                 keyRight,
697                 keyUp,
698                 keyDown,
699                 keyOk,
700                 keyUser = 0x100
701         };
702 };
703
704 SWIG_IGNORE(iServiceKeys);
705 class iServiceKeys: public iServiceKeys_ENUMS, public iObject
706 {
707 #ifdef SWIG
708         iServiceKeys();
709         ~iServiceKeys();
710 #endif
711 public:
712         virtual SWIG_VOID(RESULT) keyPressed(int key)=0;
713 };
714 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceKeys>, iServiceKeysPtr);
715
716 class iPlayableService_ENUMS
717 {
718 #ifdef SWIG
719         iPlayableService_ENUMS();
720         ~iPlayableService_ENUMS();
721 #endif
722 public:
723         enum {
724                         /* these first two events are magical, and should only
725                            be generated if you know what you're doing. */
726                 evStart,
727                 evEnd,
728
729                 evTuneFailed,
730
731                         /* when iServiceInformation is implemented:*/
732                 evUpdatedEventInfo,
733                 evUpdatedInfo,
734
735                         /* when seek() is implemented: */
736                 evSeekableStatusChanged, /* for example when timeshifting */
737
738                 evEOF,
739                 evSOF, /* bounced against start of file (when seeking backwards) */
740
741                         /* when cueSheet is implemented */
742                 evCuesheetChanged,
743
744                         /* when rdsDecoder is implemented */
745                 evUpdatedRadioText,
746                 evUpdatedRtpText,
747
748                         /* Radio Screenshow Support */
749                 evUpdatedRassSlidePic,
750                 evUpdatedRassInteractivePicMask,
751
752                 evVideoSizeChanged,
753
754                 evStopped
755         };
756 };
757
758 SWIG_IGNORE(iPlayableService);
759 class iPlayableService: public iPlayableService_ENUMS, public iObject
760 {
761 #ifdef SWIG
762         iPlayableService();
763         ~iPlaybleService();
764 #endif
765         friend class iServiceHandler;
766 public:
767 #ifndef SWIG
768         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
769 #endif
770         virtual RESULT start()=0;
771         virtual RESULT stop()=0;
772                         /* might have to be changed... */
773         virtual RESULT setTarget(int target)=0;
774         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
775         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
776         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
777         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
778         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
779         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
780         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
781         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
782         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
783         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
784         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
785         virtual SWIG_VOID(RESULT) rdsDecoder(ePtr<iRdsDecoder> &SWIG_OUTPUT)=0;
786         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
787         virtual SWIG_VOID(RESULT) keys(ePtr<iServiceKeys> &SWIG_OUTPUT)=0;
788 };
789 SWIG_TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
790
791 class iRecordableService_ENUMS
792 {
793 #ifdef SWIG
794         iRecordableService_ENUMS();
795         ~iRecordableService_ENUMS();
796 #endif
797 public:
798         enum {
799                 evStart,
800                 evEnd,
801                 evTunedIn,
802                 evTuneFailed,
803                 evRecordRunning,
804                 evRecordStopped,
805                 evNewProgramInfo,
806                 evRecordFailed,
807                 evRecordWriteError
808         };
809         enum {
810                 NoError=0,
811                 errOpenRecordFile=-1,
812                 errNoDemuxAvailable=-2,
813                 errNoTsRecorderAvailable=-3,
814                 errDiskFull=-4,
815                 errTuneFailed=-255,
816                 errMisconfiguration = -256,
817                 errNoResources = -257,
818         };
819 };
820
821 SWIG_IGNORE(iRecordableService);
822 class iRecordableService: public iRecordableService_ENUMS, public iObject
823 {
824 #ifdef SWIG
825         iRecordableService();
826         ~iRecordableService();
827 #endif
828 public:
829 #ifndef SWIG
830         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
831 #endif
832         virtual SWIG_VOID(RESULT) getError(int &SWIG_OUTPUT)=0;
833         virtual RESULT prepare(const char *filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1)=0;
834         virtual RESULT prepareStreaming()=0;
835         virtual RESULT start()=0;
836         virtual RESULT stop()=0;
837         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
838         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
839 };
840 SWIG_TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
841
842 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
843
844 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
845 {
846         return New_iRecordableServicePtr(c);
847 }
848
849 #ifndef SWIG
850 #ifdef PYTHON_REFCOUNT_DEBUG
851 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
852 {
853         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
854 }
855 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
856 #else
857 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
858 {
859         return New_iRecordableServicePtr(ptr);
860 }
861 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
862 #endif
863 #endif // SWIG
864
865 SWIG_IGNORE(iServiceHandler);
866 class iServiceHandler: public iObject
867 {
868 #ifdef SWIG
869         iServiceHandler();
870         ~iServiceHandler();
871 #endif
872 public:
873         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
874         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
875         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
876         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
877         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
878 };
879 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
880
881 #endif