4379fbb83a3aae0702fa3fc2d6777671d9effc2d
[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
148 TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
149
150 class eServiceEvent;
151
152 class iServiceInformation: public iStaticServiceInformation
153 {
154 public:
155         virtual RESULT getEvent(ePtr<eServiceEvent> &evt, int nownext);
156 };
157
158 TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
159
160 class iPauseableService: public iObject
161 {
162 public:
163         virtual RESULT pause()=0;
164         virtual RESULT unpause()=0;
165 };
166
167 TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
168
169 class iPlayableService: public iObject
170 {
171         friend class iServiceHandler;
172 public:
173         enum
174         {
175                 evStart,
176                 evEnd,
177                 
178                 // when iServiceInformation is implemented:
179                 evUpdatedEventInfo
180         };
181         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
182         virtual RESULT start()=0;
183         virtual RESULT stop()=0;
184         virtual RESULT pause(ePtr<iPauseableService> &ptr)=0;
185         virtual RESULT info(ePtr<iServiceInformation> &ptr)=0;
186 };
187
188 TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
189
190 class iRecordableService: public iObject
191 {
192 public:
193         virtual RESULT prepare()=0;
194         virtual RESULT start()=0;
195         virtual RESULT stop()=0;
196 };
197
198 TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
199
200 // TEMPLATE_TYPEDEF(std::list<eServiceReference>, eServiceReferenceList);
201
202 class iListableService: public iObject
203 {
204 public:
205         virtual RESULT getContent(std::list<eServiceReference> &list)=0;
206 };
207
208 TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
209
210 class iServiceHandler: public iObject
211 {
212 public:
213         virtual RESULT play(const eServiceReference &, ePtr<iPlayableService> &ptr)=0;
214         virtual RESULT record(const eServiceReference &, ePtr<iRecordableService> &ptr)=0;
215         virtual RESULT list(const eServiceReference &, ePtr<iListableService> &ptr)=0;
216         virtual RESULT info(const eServiceReference &, ePtr<iStaticServiceInformation> &ptr);
217 };
218
219 TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
220
221 #endif