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