update es, da language
[enigma2.git] / lib / service / servicefs.cpp
1 #include <lib/base/eerror.h>
2 #include <lib/base/object.h>
3 #include <string>
4 #include <errno.h>
5 #include <lib/service/servicefs.h>
6 #include <lib/service/service.h>
7 #include <lib/service/servicedvb.h>
8 #include <lib/base/init_num.h>
9 #include <lib/base/init.h>
10 #include <dirent.h>
11 #include <sys/types.h>
12 #include <sys/stat.h>
13 #include <unistd.h>
14
15 class eStaticServiceFSInformation: public iStaticServiceInformation
16 {
17         DECLARE_REF(eStaticServiceFSInformation);
18 public:
19         RESULT getName(const eServiceReference &ref, std::string &name);
20         int getLength(const eServiceReference &ref) { return -1; }
21 };
22
23 DEFINE_REF(eStaticServiceFSInformation);
24
25 RESULT eStaticServiceFSInformation::getName(const eServiceReference &ref, std::string &name)
26 {
27         name = ref.path;
28         return 0;
29 }
30
31 // eServiceFactoryFS
32
33 eServiceFactoryFS::eServiceFactoryFS()
34 {
35         ePtr<eServiceCenter> sc;
36         
37         eServiceCenter::getPrivInstance(sc);
38         if (sc)
39                 sc->addServiceFactory(eServiceFactoryFS::id, this);
40         
41         m_service_information = new eStaticServiceFSInformation();
42 }
43
44 eServiceFactoryFS::~eServiceFactoryFS()
45 {
46         ePtr<eServiceCenter> sc;
47         
48         eServiceCenter::getPrivInstance(sc);
49         if (sc)
50                 sc->removeServiceFactory(eServiceFactoryFS::id);
51 }
52
53 DEFINE_REF(eServiceFactoryFS)
54
55         // iServiceHandler
56 RESULT eServiceFactoryFS::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
57 {
58         ptr=0;
59         return -1;
60 }
61
62 RESULT eServiceFactoryFS::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
63 {
64         ptr=0;
65         return -1;
66 }
67
68 RESULT eServiceFactoryFS::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
69 {
70         ptr = new eServiceFS(ref.path.c_str());
71         return 0;
72 }
73
74 RESULT eServiceFactoryFS::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
75 {
76         ptr = m_service_information;
77         return 0;
78 }
79
80 RESULT eServiceFactoryFS::offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &ptr)
81 {
82         ptr = 0;
83         return -1;
84 }
85
86 // eServiceFS
87
88 DEFINE_REF(eServiceFS);
89
90 eServiceFS::eServiceFS(const char *path): path(path)
91 {
92         m_list_valid = 0;
93 }
94
95 eServiceFS::~eServiceFS()
96 {
97 }
98
99 int lower(char c)
100 {
101         return std::tolower(static_cast<unsigned char>(c));
102 }
103
104 RESULT eServiceFS::getContent(std::list<eServiceReference> &list, bool sorted)
105 {
106         DIR *d=opendir(path.c_str());
107         if (!d)
108                 return -errno;
109         while (dirent *e=readdir(d))
110         {
111                 if (!(strcmp(e->d_name, ".") && strcmp(e->d_name, "..")))
112                         continue;
113                 
114                 std::string filename;
115                 
116                 filename = path;
117                 filename += e->d_name;
118                 
119                 struct stat s;
120                 if (::stat(filename.c_str(), &s) < 0)
121                         continue;
122                 
123                 if (S_ISDIR(s.st_mode))
124                         filename += "/";
125                 
126                 if (S_ISDIR(s.st_mode))
127                 {
128                         eServiceReference service(eServiceFactoryFS::id, 
129                                 eServiceReference::isDirectory|
130                                 eServiceReference::canDescent|eServiceReference::mustDescent|
131                                 eServiceReference::shouldSort|eServiceReference::sort1,
132                                 filename);
133                         service.data[0] = 1;
134                         list.push_back(service);
135                 } else
136                 {
137                         size_t e = filename.rfind('.');
138                         std::string extension = (e != std::string::npos) ? filename.substr(e) : "";
139                         std::transform(extension.begin(), extension.end(), extension.begin(), lower);
140                         int type = -1;
141                         
142                         if (extension == ".ts")
143                                 type = eServiceFactoryDVB::id;
144                         else if (extension == ".mp3")
145                                 type = 0x1001;
146                         else if (extension == ".ogg")
147                                 type = 0x1001;
148                         else if (extension == ".mpg")
149                                 type = 0x1001;
150                         else if (extension == ".vob")
151                                 type = 0x1001;
152                         else if (extension == ".wav" || extension == ".wave")
153                                 type = 0x1001;
154                         else if (extension == ".m3u" || extension == ".pls" || extension == ".e2pls")
155                                 type = 4098; // ?? this id is not defined in any service handler, just in python code.
156                         
157                         if (type != -1)
158                         {
159                                 eServiceReference service(type,
160                                         0,
161                                         filename);
162                                 service.data[0] = 0;
163                                 list.push_back(service);
164                         }
165                 }
166         }
167         closedir(d);
168
169         if (sorted)
170                 list.sort(iListableServiceCompare(this));
171
172         return 0;
173 }
174
175 //   The first argument of this function is a format string to specify the order and
176 //   the content of the returned list
177 //   useable format options are
178 //   R = Service Reference (as swig object .. this is very slow)
179 //   S = Service Reference (as python string object .. same as ref.toString())
180 //   C = Service Reference (as python string object .. same as ref.toCompareString())
181 //   N = Service Name (as python string object)
182 //   when exactly one return value per service is selected in the format string,
183 //   then each value is directly a list entry
184 //   when more than one value is returned per service, then the list is a list of
185 //   python tuples
186 //   unknown format string chars are returned as python None values !
187 PyObject *eServiceFS::getContent(const char* format, bool sorted)
188 {
189         ePyObject ret;
190         std::list<eServiceReference> tmplist;
191         int retcount=1;
192
193         if (!format || !(retcount=strlen(format)))
194                 format = "R"; // just return service reference swig object ...
195
196         if (!getContent(tmplist, sorted))
197         {
198                 int services=tmplist.size();
199                 ePtr<iStaticServiceInformation> sptr;
200                 eServiceCenterPtr service_center;
201
202                 if (strchr(format, 'N'))
203                         eServiceCenter::getPrivInstance(service_center);
204
205                 ret = PyList_New(services);
206                 std::list<eServiceReference>::iterator it(tmplist.begin());
207
208                 for (int cnt=0; cnt < services; ++cnt)
209                 {
210                         eServiceReference &ref=*it++;
211                         ePyObject tuple = retcount > 1 ? PyTuple_New(retcount) : ePyObject();
212                         for (int i=0; i < retcount; ++i)
213                         {
214                                 ePyObject tmp;
215                                 switch(format[i])
216                                 {
217                                 case 'R':  // service reference (swig)object
218                                         tmp = NEW_eServiceReference(ref);
219                                         break;
220                                 case 'C':  // service reference compare string
221                                         tmp = PyString_FromString(ref.toCompareString().c_str());
222                                         break;
223                                 case 'S':  // service reference string
224                                         tmp = PyString_FromString(ref.toString().c_str());
225                                         break;
226                                 case 'N':  // service name
227                                         if (service_center)
228                                         {
229                                                 service_center->info(ref, sptr);
230                                                 if (sptr)
231                                                 {
232                                                         std::string name;
233                                                         sptr->getName(ref, name);
234                                                         if (name.length())
235                                                                 tmp = PyString_FromString(name.c_str());
236                                                 }
237                                         }
238                                         if (!tmp)
239                                                 tmp = PyString_FromString("<n/a>");
240                                         break;
241                                 default:
242                                         if (tuple)
243                                         {
244                                                 tmp = Py_None;
245                                                 Py_INCREF(Py_None);
246                                         }
247                                         break;
248                                 }
249                                 if (tmp)
250                                 {
251                                         if (tuple)
252                                                 PyTuple_SET_ITEM(tuple, i, tmp);
253                                         else
254                                                 PyList_SET_ITEM(ret, cnt, tmp);
255                                 }
256                         }
257                         if (tuple)
258                                 PyList_SET_ITEM(ret, cnt, tuple);
259                 }
260         }
261         return ret ? (PyObject*)ret : (PyObject*)PyList_New(0);
262 }
263
264 RESULT eServiceFS::getNext(eServiceReference &ptr)
265 {
266         if (!m_list_valid)
267         {
268                 m_list_valid = 1;
269                 int res = getContent(m_list);
270                 if (res)
271                         return res;
272         }
273         
274         if (!m_list.size())
275         {
276                 ptr = eServiceReference();
277                 return -ERANGE;
278         }
279         
280         ptr = m_list.front();
281         m_list.pop_front();
282         return 0;
283 }
284
285 int eServiceFS::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
286 {
287                 /* directories first */
288         if ((a.flags & ~b.flags) & eServiceReference::isDirectory)
289                 return 1;
290         else if ((~a.flags & b.flags) & eServiceReference::isDirectory)
291                 return 0;
292                 /* sort by filename */
293         else
294                 return a.path < b.path;
295 }
296
297 RESULT eServiceFS::startEdit(ePtr<iMutableServiceList> &res)
298 {
299         res = 0;
300         return -1;
301 }
302
303 eAutoInitPtr<eServiceFactoryFS> init_eServiceFactoryFS(eAutoInitNumbers::service+1, "eServiceFactoryFS");