fix
[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/base/object.h>
6 #include <string>
7 #include <connection.h>
8 #include <list>
9
10 class eServiceReference
11 {
12 public:
13         enum
14         {
15                 idInvalid=-1,
16                 idStructure,    // service_id == 0 is root
17                 idDVB,
18                 idFile,
19                 idUser=0x1000
20         };
21         int type;
22
23         int flags; // flags will NOT be compared.
24         enum
25         {
26                 isDirectory=1,          // SHOULD enter  (implies mustDescent)
27                 mustDescent=2,          // cannot be played directly - often used with "isDirectory" (implies canDescent)
28                 /*
29                         for example:
30                                 normal services have none of them - they can be fed directly into the "play"-handler.
31                                 normal directories have both of them set - you cannot play a directory directly and the UI should descent into it.
32                                 playlists have "mustDescent", but not "isDirectory" - you don't want the user to browse inside the playlist (unless he really wants)
33                                 services with sub-services have none of them, instead the have the "canDecsent" flag (as all of the above)
34                 */
35                 canDescent=4,                   // supports enterDirectory/leaveDirectory
36                 flagDirectory=isDirectory|mustDescent|canDescent,
37                 shouldSort=8,                   // should be ASCII-sorted according to service_name. great for directories.
38                 hasSortKey=16,          // has a sort key in data[3]. not having a sort key implies 0.
39                 sort1=32                                        // sort key is 1 instead of 0
40         };
41
42         inline int getSortKey() const { return (flags & hasSortKey) ? data[3] : ((flags & sort1) ? 1 : 0); }
43
44         int data[8];
45         std::string path;
46
47 // only for override service names in bouquets or to give servicerefs a name which not have a
48 // real existing service ( for dvb eServiceDVB )
49         std::string name;
50
51         eServiceReference()
52                 : type(idInvalid), flags(0)
53         {
54         }
55
56         eServiceReference(int type, int flags)
57                 : type(type), flags(flags)
58         {
59                 memset(data, 0, sizeof(data));
60         }
61         eServiceReference(int type, int flags, int data0)
62                 : type(type), flags(flags)
63         {
64                 memset(data, 0, sizeof(data));
65                 data[0]=data0;
66         }
67         eServiceReference(int type, int flags, int data0, int data1)
68                 : type(type), flags(flags)
69         {
70                 memset(data, 0, sizeof(data));
71                 data[0]=data0;
72                 data[1]=data1;
73         }
74         eServiceReference(int type, int flags, int data0, int data1, int data2)
75                 : type(type), flags(flags)
76         {
77                 memset(data, 0, sizeof(data));
78                 data[0]=data0;
79                 data[1]=data1;
80                 data[2]=data2;
81         }
82         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
83                 : type(type), flags(flags)
84         {
85                 memset(data, 0, sizeof(data));
86                 data[0]=data0;
87                 data[1]=data1;
88                 data[2]=data2;
89                 data[3]=data3;
90         }
91         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
92                 : type(type), flags(flags)
93         {
94                 memset(data, 0, sizeof(data));
95                 data[0]=data0;
96                 data[1]=data1;
97                 data[2]=data2;
98                 data[3]=data3;
99                 data[4]=data4;
100         }
101         eServiceReference(int type, int flags, const std::string &path)
102                 : type(type), flags(flags), path(path)
103         {
104                 memset(data, 0, sizeof(data));
105         }
106         eServiceReference(const std::string &string);
107         std::string toString() const;
108         bool operator==(const eServiceReference &c) const
109         {
110                 if (type != c.type)
111                         return 0;
112                 return (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
113         }
114         bool operator!=(const eServiceReference &c) const
115         {
116                 return !(*this == c);
117         }
118         bool operator<(const eServiceReference &c) const
119         {
120                 if (type < c.type)
121                         return 1;
122
123                 if (type > c.type)
124                         return 0;
125
126                 int r=memcmp(data, c.data, sizeof(int)*8);
127                 if (r)
128                         return r < 0;
129                 return path < c.path;
130         }
131         operator bool() const
132         {
133                 return valid();
134         }
135         
136         int valid() const
137         {
138                 return type != idInvalid;
139         }
140 };
141
142 SWIG_ALLOW_OUTPUT_SIMPLE(eServiceReference);
143
144 typedef long long pts_t;
145
146         /* the reason we have the servicereference as additional argument is
147            that we don't have to create one object for every entry in a possibly
148            large list, provided that no state information is nessesary to deliver
149            the required information. Anyway - ref *must* be the same as the argument
150            to the info() or getIServiceInformation call! */
151
152         /* About the usage of SWIG_VOID:
153            SWIG_VOID(real_returntype_t) hides a return value from swig. This is used for
154            the "superflouus" RESULT return values.
155            
156            Python code has to check the returned pointer against 0. This works,
157            as all functions returning instances in smartpointers AND having a 
158            RESULT have to BOTH return non-zero AND set the pointer to zero.
159            
160            Python code thus can't check for the reason, but the reason isn't
161            user-servicable anyway. If you want to return a real reason which
162            goes beyong "it just doesn't work", use extra variables for this,
163            not the RESULT.
164            
165            Hide the result only if there is another way to check for failure! */
166            
167 class iStaticServiceInformation: public iObject
168 {
169 public:
170         virtual SWIG_VOID(RESULT) getName(const eServiceReference &ref, std::string &SWIG_OUTPUT)=0;
171         
172                 // doesn't need to be implemented, should return -1 then.
173         virtual int getLength(const eServiceReference &ref)=0;
174 };
175
176 TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
177
178 class eServiceEvent;
179
180 TEMPLATE_TYPEDEF(ePtr<eServiceEvent>, eServiceEventPtr);
181
182 class iServiceInformation: public iObject
183 {
184 public:
185         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
186         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
187
188         enum { 
189                 sIsCrypted,  /* is encrypted (no indication if decrypt was possible) */
190                 sAspect,     /* aspect ratio: 0=4:3, 1=16:9, 2=whatever we need */
191                 sIsMultichannel, /* multichannel *available* (probably not selected) */
192                 
193                         /* "user serviceable info" - they are not reliable. Don't use them for anything except the service menu!
194                            that's also the reason why they are so globally defined. 
195                            
196                            
197                            again - if somebody EVER tries to use this information for anything else than simply displaying it,
198                            i will change this to return a user-readable text like "zero x zero three three" (and change the
199                            exact spelling in every version) to stop that!
200                         */
201                 sVideoPID,
202                 sAudioPID,
203                 sPCRPID,
204                 sPMTPID,
205                 sTXTPID,
206                 
207                 sSID,
208                 sONID,
209                 sTSID,
210                 sNamespace,
211                 sProvider,
212         };
213         enum { resNA = -1, resIsString = -2 };
214
215         virtual int getInfo(int w);
216         virtual std::string getInfoString(int w);
217 };
218
219 TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
220
221 class iPauseableService: public iObject
222 {
223 public:
224         virtual RESULT pause()=0;
225         virtual RESULT unpause()=0;
226 };
227
228 TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
229
230 class iSeekableService: public iObject
231 {
232 public:
233         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
234         virtual RESULT seekTo(pts_t to)=0;
235         enum { dirForward = +1, dirBackward = -1 };
236         virtual RESULT seekRelative(int direction, pts_t to)=0;
237         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
238 };
239
240 TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
241
242 struct iAudioTrackInfo
243 {
244         std::string m_description;
245         std::string m_language; /* iso639 */
246         
247         std::string getDescription() { return m_description; }
248         std::string getLanguage() { return m_language; }
249 };
250
251 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
252
253 class iAudioTrackSelection: public iObject
254 {
255 public:
256         virtual int getNumberOfTracks()=0;
257         virtual RESULT selectTrack(unsigned int i)=0;
258         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
259 };
260
261 TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
262
263
264 class iPlayableService: public iObject
265 {
266         friend class iServiceHandler;
267 public:
268         enum
269         {
270                 evStart,
271                 evEnd,
272                 
273                 evTuneFailed,
274                         // when iServiceInformation is implemented:
275                 evUpdatedEventInfo,
276                 evUpdatedInfo,
277         };
278         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
279         virtual RESULT start()=0;
280         virtual RESULT stop()=0;
281         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
282         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
283         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
284         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
285 };
286
287 TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
288
289 class iRecordableService: public iObject
290 {
291 public:
292         virtual RESULT prepare(const char *filename)=0;
293         virtual RESULT start()=0;
294         virtual RESULT stop()=0;
295 };
296
297 TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
298
299 // TEMPLATE_TYPEDEF(std::list<eServiceReference>, eServiceReferenceList);
300
301 class iMutableServiceList: public iObject
302 {
303 public:
304                 /* flush changes */
305         virtual RESULT flushChanges()=0;
306                 /* adds a service to a list */
307         virtual RESULT addService(eServiceReference &ref)=0;
308                 /* removes a service from a list */
309         virtual RESULT removeService(eServiceReference &ref)=0;
310                 /* moves a service in a list, only if list suppports a specific sort method. */
311                 /* pos is the new, absolute position from 0..size-1 */
312         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
313 };
314
315 TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
316
317 class iListableService: public iObject
318 {
319 public:
320                 /* legacy interface: get a list */
321         virtual RESULT getContent(std::list<eServiceReference> &list)=0;
322         
323                 /* new, shiny interface: streaming. */
324         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
325         
326                 /* use this for sorting. output is not sorted because of either
327                  - performance reasons: the whole list must be buffered or
328                  - the interface would be restricted to a list. streaming
329                    (as well as a future "active" extension) won't be possible.
330                 */
331         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
332         
333         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
334 };
335
336 TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
337
338         /* a helper class which can be used as argument to stl's sort(). */
339 class iListableServiceCompare
340 {
341         ePtr<iListableService> m_list;
342 public:
343         iListableServiceCompare(iListableService *list): m_list(list) { }
344         bool operator()(const eServiceReference &a, const eServiceReference &b)
345         {
346                 return m_list->compareLessEqual(a, b);
347         }
348 };
349
350 class iServiceOfflineOperations: public iObject
351 {
352 public:
353                 /* to delete a service, forever. */
354         virtual RESULT deleteFromDisk(int simulate=1)=0;
355         
356                 /* for transferring a service... */
357         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
358         
359                 // TODO: additional stuff, like a conversion interface?
360 };
361
362 TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
363
364 class iServiceHandler: public iObject
365 {
366 public:
367         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
368         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
369         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
370         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
371         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
372 };
373
374 TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
375
376 #endif