- split iStaticServiceInformation against iServiceInformation
[openblackhole/openblackhole-enigma2.git] / lib / service / iservice.h
1 #ifndef __lib_dvb_iservice_h
2 #define __lib_dvb_iservice_h
3
4 #include <lib/base/object.h>
5 #include <string>
6 #include <connection.h>
7 #include <list>
8
9 class eServiceReference
10 {
11 public:
12         enum
13         {
14                 idInvalid=-1,
15                 idStructure,    // service_id == 0 is root
16                 idDVB,
17                 idFile,
18                 idUser=0x1000
19         };
20         int type;
21
22         int flags; // flags will NOT be compared.
23         enum
24         {
25                 isDirectory=1,          // SHOULD enter  (implies mustDescent)
26                 mustDescent=2,          // cannot be played directly - often used with "isDirectory" (implies canDescent)
27                 /*
28                         for example:
29                                 normal services have none of them - they can be fed directly into the "play"-handler.
30                                 normal directories have both of them set - you cannot play a directory directly and the UI should descent into it.
31                                 playlists have "mustDescent", but not "isDirectory" - you don't want the user to browse inside the playlist (unless he really wants)
32                                 services with sub-services have none of them, instead the have the "canDecsent" flag (as all of the above)
33                 */
34                 canDescent=4,                   // supports enterDirectory/leaveDirectory
35                 flagDirectory=isDirectory|mustDescent|canDescent,
36                 shouldSort=8,                   // should be ASCII-sorted according to service_name. great for directories.
37                 hasSortKey=16,          // has a sort key in data[3]. not having a sort key implies 0.
38                 sort1=32                                        // sort key is 1 instead of 0
39         };
40
41         inline int getSortKey() const { return (flags & hasSortKey) ? data[3] : ((flags & sort1) ? 1 : 0); }
42
43         int data[8];
44         std::string path;
45
46         eServiceReference()
47                 : type(idInvalid), flags(0)
48         {
49         }
50
51         eServiceReference(int type, int flags)
52                 : type(type), flags(flags)
53         {
54                 memset(data, 0, sizeof(data));
55         }
56         eServiceReference(int type, int flags, int data0)
57                 : type(type), flags(flags)
58         {
59                 memset(data, 0, sizeof(data));
60                 data[0]=data0;
61         }
62         eServiceReference(int type, int flags, int data0, int data1)
63                 : type(type), flags(flags)
64         {
65                 memset(data, 0, sizeof(data));
66                 data[0]=data0;
67                 data[1]=data1;
68         }
69         eServiceReference(int type, int flags, int data0, int data1, int data2)
70                 : type(type), flags(flags)
71         {
72                 memset(data, 0, sizeof(data));
73                 data[0]=data0;
74                 data[1]=data1;
75                 data[2]=data2;
76         }
77         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
78                 : type(type), flags(flags)
79         {
80                 memset(data, 0, sizeof(data));
81                 data[0]=data0;
82                 data[1]=data1;
83                 data[2]=data2;
84                 data[3]=data3;
85         }
86         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
87                 : type(type), flags(flags)
88         {
89                 memset(data, 0, sizeof(data));
90                 data[0]=data0;
91                 data[1]=data1;
92                 data[2]=data2;
93                 data[3]=data3;
94                 data[4]=data4;
95         }
96         eServiceReference(int type, int flags, const std::string &path)
97                 : type(type), flags(flags), path(path)
98         {
99                 memset(data, 0, sizeof(data));
100         }
101         eServiceReference(const std::string &string);
102         std::string toString() const;
103         bool operator==(const eServiceReference &c) const
104         {
105                 if (type != c.type)
106                         return 0;
107                 return /* (flags == c.flags) && */ (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
108         }
109         bool operator!=(const eServiceReference &c) const
110         {
111                 return !(*this == c);
112         }
113         bool operator<(const eServiceReference &c) const
114         {
115                 if (type < c.type)
116                         return 1;
117
118                 if (type > c.type)
119                         return 0;
120                         
121 /*              if (flags < c.flags)
122                         return 1;
123                 if (flags > c.flags)
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 type != idInvalid;
134         }
135 };
136
137         /* the reason we have the servicereference as additional argument is
138            that we don't have to create one object for every entry in a possibly
139            large list, provided that no state information is nessesary to deliver
140            the required information. Anyway - ref *must* be the same as the argument
141            to the info() or getIServiceInformation call! */
142 class iStaticServiceInformation: public iObject
143 {
144 public:
145         virtual RESULT getName(const eServiceReference &ref, std::string &name)=0;
146
147                 // FOR SWIG
148         std::string getName(const eServiceReference &ref) { std::string temp; getName(ref, temp); return temp; }
149 };
150
151 TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
152
153 class eServiceEvent;
154
155 class iServiceInformation: public iObject
156 {
157 public:
158         virtual RESULT getName(std::string &name)=0;
159                 // FOR SWIG
160         std::string getName() { std::string temp; getName(temp); return temp; }
161         virtual RESULT getEvent(ePtr<eServiceEvent> &evt, int nownext);
162 };
163
164 TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
165
166 class iPauseableService: public iObject
167 {
168 public:
169         virtual RESULT pause()=0;
170         virtual RESULT unpause()=0;
171 };
172
173 TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
174
175 class iPlayableService: public iObject
176 {
177         friend class iServiceHandler;
178 public:
179         enum
180         {
181                 evStart,
182                 evEnd,
183                 
184                 // when iServiceInformation is implemented:
185                 evUpdatedEventInfo
186         };
187         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
188         virtual RESULT start()=0;
189         virtual RESULT stop()=0;
190         virtual RESULT pause(ePtr<iPauseableService> &ptr)=0;
191         virtual RESULT info(ePtr<iServiceInformation> &ptr)=0;
192 };
193
194 TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
195
196 class iRecordableService: public iObject
197 {
198 public:
199         virtual RESULT prepare()=0;
200         virtual RESULT start()=0;
201         virtual RESULT stop()=0;
202 };
203
204 TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
205
206 // TEMPLATE_TYPEDEF(std::list<eServiceReference>, eServiceReferenceList);
207
208 class iListableService: public iObject
209 {
210 public:
211         virtual RESULT getContent(std::list<eServiceReference> &list)=0;
212 };
213
214 TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
215
216 class iServiceHandler: public iObject
217 {
218 public:
219         virtual RESULT play(const eServiceReference &, ePtr<iPlayableService> &ptr)=0;
220         virtual RESULT record(const eServiceReference &, ePtr<iRecordableService> &ptr)=0;
221         virtual RESULT list(const eServiceReference &, ePtr<iListableService> &ptr)=0;
222         virtual RESULT info(const eServiceReference &, ePtr<iStaticServiceInformation> &ptr);
223 };
224
225 TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
226
227 #endif