add TODO
[enigma2.git] / lib / service / service.cpp
1 #include <lib/base/eerror.h>
2 #include <lib/base/estring.h>
3 #include <lib/python/python.h>
4 #include <lib/service/service.h>
5 #include <lib/base/init_num.h>
6 #include <lib/base/init.h>
7 #include <lib/python/python.h>
8
9 eServiceReference::eServiceReference(const std::string &string)
10 {
11         const char *c=string.c_str();
12         int pathl=0;
13
14         if (!string.length())
15                 type = idInvalid;
16         else if ( sscanf(c, "%d:%d:%x:%x:%x:%x:%x:%x:%x:%x:%n", &type, &flags, &data[0], &data[1], &data[2], &data[3], &data[4], &data[5], &data[6], &data[7], &pathl) < 8 )
17         {
18                 memset( data, 0, sizeof(data) );
19                 eDebug("find old format eServiceReference string");
20                 if ( sscanf(c, "%d:%d:%x:%x:%x:%x:%n", &type, &flags, &data[0], &data[1], &data[2], &data[3], &pathl) < 2 )
21                         type = idInvalid;
22         }
23
24         if (pathl)
25         {
26                 const char *pathstr = c+pathl;
27                 const char *namestr = strchr(pathstr, ':');
28                 if (namestr)
29                 {
30                         if (pathstr != namestr)
31                                 path.assign(pathstr, namestr-pathstr);
32                         if (*(namestr+1))
33                                 name=namestr+1;
34                 }
35                 else
36                         path=pathstr;
37         }
38 }
39
40 std::string eServiceReference::toString() const
41 {
42         std::string ret;
43         ret += getNum(type);
44         ret += ":";
45         ret += getNum(flags);
46         for (unsigned int i=0; i<sizeof(data)/sizeof(*data); ++i)
47                 ret+=":"+ getNum(data[i], 0x10);
48         ret+=":"+path; /* we absolutely have a problem when the path contains a ':' (for example: http://). we need an encoding here. */
49         if (name.length())
50                 ret+=":"+name;
51         return ret;
52 }
53
54 std::string eServiceReference::toCompareString() const
55 {
56         std::string ret;
57         ret += getNum(type);
58         ret += ":0";
59         for (unsigned int i=0; i<sizeof(data)/sizeof(*data); ++i)
60                 ret+=":"+getNum(data[i], 0x10);
61         ret+=":"+path;
62         return ret;
63 }
64
65 eServiceCenter *eServiceCenter::instance;
66
67 eServiceCenter::eServiceCenter()
68 {
69         if (!instance)
70         {
71                 eDebug("settings instance.");
72                 instance = this;
73         }
74 }
75
76 eServiceCenter::~eServiceCenter()
77 {
78         if (instance == this)
79         {
80                 eDebug("clear instance");
81                 instance = 0;
82         }
83 }
84
85 DEFINE_REF(eServiceCenter);
86
87 RESULT eServiceCenter::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
88 {
89         std::map<int,ePtr<iServiceHandler> >::iterator i = handler.find(ref.type);
90         if (i == handler.end())
91         {
92                 ptr = 0;
93                 return -1;
94         }
95         return i->second->play(ref, ptr);
96 }
97
98 RESULT eServiceCenter::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
99 {
100         std::map<int,ePtr<iServiceHandler> >::iterator i = handler.find(ref.type);
101         if (i == handler.end())
102         {
103                 ptr = 0;
104                 return -1;
105         }
106         return i->second->record(ref, ptr);
107 }
108
109 RESULT eServiceCenter::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
110 {
111         std::map<int,ePtr<iServiceHandler> >::iterator i = handler.find(ref.type);
112         if (i == handler.end())
113         {
114                 ptr = 0;
115                 return -1;
116         }
117         return i->second->list(ref, ptr);
118 }
119
120 RESULT eServiceCenter::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
121 {
122         std::map<int,ePtr<iServiceHandler> >::iterator i = handler.find(ref.type);
123         if (i == handler.end())
124         {
125                 ptr = 0;
126                 return -1;
127         }
128         return i->second->info(ref, ptr);
129 }
130
131 RESULT eServiceCenter::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
132 {
133         std::map<int,ePtr<iServiceHandler> >::iterator i = handler.find(ref.type);
134         if (i == handler.end())
135         {
136                 ptr = 0;
137                 return -1;
138         }
139         return i->second->offlineOperations(ref, ptr);
140 }
141
142 RESULT eServiceCenter::addServiceFactory(int id, iServiceHandler *hnd)
143 {
144         handler.insert(std::pair<int,ePtr<iServiceHandler> >(id, hnd));
145         return 0;
146 }
147
148 RESULT eServiceCenter::removeServiceFactory(int id)
149 {
150         handler.erase(id);
151         return 0;
152 }
153
154         /* default handlers */
155 RESULT iServiceHandler::info(const eServiceReference &, ePtr<iStaticServiceInformation> &ptr)
156 {
157         ptr = 0;
158         return -1;
159 }
160
161 #include <lib/service/event.h>
162
163 RESULT iStaticServiceInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &evt, time_t start_time)
164 {
165         evt = 0;
166         return -1;
167 }
168
169 int iStaticServiceInformation::getLength(const eServiceReference &ref)
170 {
171         return -1;
172 }
173
174 int iStaticServiceInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore)
175 {
176         return 0;
177 }
178
179 RESULT iServiceInformation::getEvent(ePtr<eServiceEvent> &evt, int m_nownext)
180 {
181         evt = 0;
182         return -1;
183 }
184
185 int iStaticServiceInformation::getInfo(const eServiceReference &ref, int w)
186 {
187         return -1;
188 }
189
190 std::string iStaticServiceInformation::getInfoString(const eServiceReference &ref, int w)
191 {
192         return "";
193 }
194
195 int iServiceInformation::getInfo(int w)
196 {
197         return -1;
198 }
199
200 std::string iServiceInformation::getInfoString(int w)
201 {
202         return "";
203 }
204
205 PyObject* iServiceInformation::getInfoObject(int w)
206 {
207         Py_INCREF(Py_None);
208         return Py_None;
209 }
210
211 int iStaticServiceInformation::setInfo(const eServiceReference &ref, int w, int v)
212 {
213         return -1;
214 }
215
216 int iStaticServiceInformation::setInfoString(const eServiceReference &ref, int w, const char *v)
217 {
218         return -1;
219 }
220
221 int iServiceInformation::setInfo(int w, int v)
222 {
223         return -1;
224 }
225
226 int iServiceInformation::setInfoString(int w, const char *v)
227 {
228         return -1;
229 }
230
231 eAutoInitPtr<eServiceCenter> init_eServiceCenter(eAutoInitNumbers::service, "eServiceCenter");