swig: some more simplifying magic
[openblackhole/openblackhole-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         eServiceReference()
48                 : type(idInvalid), flags(0)
49         {
50         }
51
52         eServiceReference(int type, int flags)
53                 : type(type), flags(flags)
54         {
55                 memset(data, 0, sizeof(data));
56         }
57         eServiceReference(int type, int flags, int data0)
58                 : type(type), flags(flags)
59         {
60                 memset(data, 0, sizeof(data));
61                 data[0]=data0;
62         }
63         eServiceReference(int type, int flags, int data0, int data1)
64                 : type(type), flags(flags)
65         {
66                 memset(data, 0, sizeof(data));
67                 data[0]=data0;
68                 data[1]=data1;
69         }
70         eServiceReference(int type, int flags, int data0, int data1, int data2)
71                 : type(type), flags(flags)
72         {
73                 memset(data, 0, sizeof(data));
74                 data[0]=data0;
75                 data[1]=data1;
76                 data[2]=data2;
77         }
78         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
79                 : type(type), flags(flags)
80         {
81                 memset(data, 0, sizeof(data));
82                 data[0]=data0;
83                 data[1]=data1;
84                 data[2]=data2;
85                 data[3]=data3;
86         }
87         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
88                 : type(type), flags(flags)
89         {
90                 memset(data, 0, sizeof(data));
91                 data[0]=data0;
92                 data[1]=data1;
93                 data[2]=data2;
94                 data[3]=data3;
95                 data[4]=data4;
96         }
97         eServiceReference(int type, int flags, const std::string &path)
98                 : type(type), flags(flags), path(path)
99         {
100                 memset(data, 0, sizeof(data));
101         }
102         eServiceReference(const std::string &string);
103         std::string toString() const;
104         bool operator==(const eServiceReference &c) const
105         {
106                 if (type != c.type)
107                         return 0;
108                 return /* (flags == c.flags) && */ (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
109         }
110         bool operator!=(const eServiceReference &c) const
111         {
112                 return !(*this == c);
113         }
114         bool operator<(const eServiceReference &c) const
115         {
116                 if (type < c.type)
117                         return 1;
118
119                 if (type > c.type)
120                         return 0;
121                         
122 /*              if (flags < c.flags)
123                         return 1;
124                 if (flags > c.flags)
125                         return 0; */
126
127                 int r=memcmp(data, c.data, sizeof(int)*8);
128                 if (r)
129                         return r < 0;
130                 return path < c.path;
131         }
132         operator bool() const
133         {
134                 return valid();
135         }
136         
137         int valid() const
138         {
139                 return type != idInvalid;
140         }
141 };
142
143 SWIG_ALLOW_OUTPUT_SIMPLE(eServiceReference);
144
145 typedef unsigned long long pts_t;
146
147         /* the reason we have the servicereference as additional argument is
148            that we don't have to create one object for every entry in a possibly
149            large list, provided that no state information is nessesary to deliver
150            the required information. Anyway - ref *must* be the same as the argument
151            to the info() or getIServiceInformation call! */
152
153         /* About the usage of SWIG_VOID:
154            SWIG_VOID(real_returntype_t) hides a return value from swig. This is used for
155            the "superflouus" RESULT return values.
156            
157            Python code has to check the returned pointer against 0. This works,
158            as all functions returning instances in smartpointers AND having a 
159            RESULT have to BOTH return non-zero AND set the pointer to zero.
160            
161            Python code thus can't check for the reason, but the reason isn't
162            user-servicable anyway. If you want to return a real reason which
163            goes beyong "it just doesn't work", use extra variables for this,
164            not the RESULT.
165            
166            Hide the result only if there is another way to check for failure! */
167            
168 class iStaticServiceInformation: public iObject
169 {
170 public:
171         virtual SWIG_VOID(RESULT) getName(const eServiceReference &ref, std::string &SWIG_OUTPUT)=0;
172         
173                 // doesn't need to be implemented, should return -1 then.
174         virtual int getLength(const eServiceReference &ref)=0;
175 };
176
177 TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
178
179 class eServiceEvent;
180
181 TEMPLATE_TYPEDEF(ePtr<eServiceEvent>, eServiceEventPtr);
182
183 class iServiceInformation: public iObject
184 {
185 public:
186         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
187         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
188 };
189
190 TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
191
192 class iPauseableService: public iObject
193 {
194 public:
195         virtual RESULT pause()=0;
196         virtual RESULT unpause()=0;
197 };
198
199 TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
200
201 class iSeekableService: public iObject
202 {
203 public:
204         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
205         virtual RESULT seekTo(pts_t to)=0;
206         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
207 };
208
209 TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
210
211 class iPlayableService: public iObject
212 {
213         friend class iServiceHandler;
214 public:
215         enum
216         {
217                 evStart,
218                 evEnd,
219                 
220                 // when iServiceInformation is implemented:
221                 evUpdatedEventInfo
222         };
223         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
224         virtual RESULT start()=0;
225         virtual RESULT stop()=0;
226         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
227         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
228         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
229 };
230
231 TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
232
233 class iRecordableService: public iObject
234 {
235 public:
236         virtual RESULT prepare()=0;
237         virtual RESULT start()=0;
238         virtual RESULT stop()=0;
239 };
240
241 TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
242
243 // TEMPLATE_TYPEDEF(std::list<eServiceReference>, eServiceReferenceList);
244
245 class iListableService: public iObject
246 {
247 public:
248                 /* legacy interface: get a list */
249         virtual RESULT getContent(std::list<eServiceReference> &list)=0;
250         
251                 /* new, shiny interface: streaming. */
252         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
253 };
254
255 TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
256
257 class iServiceOfflineOperations: public iObject
258 {
259 public:
260                 /* to delete a service, forever. */
261         virtual RESULT deleteFromDisk(int simulate=1)=0;
262         
263                 /* for transferring a service... */
264         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
265         
266                 // TODO: additional stuff, like a conversion interface?
267 };
268
269 class iServiceHandler: public iObject
270 {
271 public:
272         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
273         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
274         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
275         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
276         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
277 };
278
279 TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
280
281 #endif