fix some imports
[enigma2.git] / lib / python / Plugins / Extensions / MediaPlayer / plugin.py
1 from os import path as os_path, remove as os_remove, listdir as os_listdir
2 from time import strftime
3 from enigma import eTimer, eServiceCenter, iServiceInformation
4 from Screens.Screen import Screen
5 from Screens.MessageBox import MessageBox
6 from Screens.InputBox import InputBox
7 from Components.ActionMap import NumberActionMap, HelpableActionMap
8 from Components.Label import Label
9 from Components.Pixmap import Pixmap
10 from Components.Label import Label
11 from Components.FileList import FileList
12 from Components.MediaPlayer import PlayList
13 from Tools.Directories import resolveFilename, SCOPE_CONFIG, SCOPE_PLAYLIST, SCOPE_SKIN_IMAGE
14 from Components.ServicePosition import ServicePositionGauge
15 from Components.ServiceEventTracker import InfoBarBase
16 from Components.Playlist import PlaylistIOInternal, PlaylistIOM3U, PlaylistIOPLS
17 from Screens.InfoBarGenerics import InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications
18 from ServiceReference import ServiceReference
19 from Screens.ChoiceBox import ChoiceBox
20 from Screens.HelpMenu import HelpableScreen
21 import random
22
23 class MyPlayList(PlayList):
24         def __init__(self):
25                 PlayList.__init__(self)
26
27         def PlayListShuffle(self):
28                 random.shuffle(self.list)
29                 self.l.setList(self.list)
30                 self.currPlaying = -1
31                 self.oldCurrPlaying = -1
32
33 class MediaPixmap(Pixmap):
34         def applySkin(self, desktop, screen):
35                 self.default_pixmap = None
36                 if self.skinAttributes is not None:
37                         for (attrib, value) in self.skinAttributes:
38                                 if attrib == "pixmap":
39                                         self.default_pixmap = value
40                                         break
41                 if self.default_pixmap is None:
42                         self.default_pixmap = resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/no_coverArt.png")
43                 return Pixmap.applySkin(self, desktop, screen)
44
45 class MediaPlayer(Screen, InfoBarBase, InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications, HelpableScreen):
46         ALLOW_SUSPEND = True
47         ENABLE_RESUME_SUPPORT = True
48
49         def __init__(self, session, args = None):
50                 Screen.__init__(self, session)
51                 InfoBarAudioSelection.__init__(self)
52                 InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
53                 InfoBarNotifications.__init__(self)
54                 InfoBarBase.__init__(self)
55                 HelpableScreen.__init__(self)
56                 self.summary = None
57                 self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
58                 self.session.nav.stopService()
59
60                 self.playlistparsers = {}
61                 self.addPlaylistParser(PlaylistIOM3U, "m3u")
62                 self.addPlaylistParser(PlaylistIOPLS, "pls")
63                 self.addPlaylistParser(PlaylistIOInternal, "e2pls")
64
65                 # 'None' is magic to start at the list of mountpoints
66                 self.filelist = FileList(None, matchingPattern = "(?i)^.*\.(mp3|ogg|ts|wav|wave|m3u|pls|e2pls|mpg|vob)", useServiceRef = True, additionalExtensions = "4098:m3u 4098:e2pls 4098:pls")
67                 self["filelist"] = self.filelist
68
69                 self.playlist = MyPlayList()
70                 #self.playlist = PlayList()
71                 self.is_closing = False
72                 self.delname = ""
73                 self["playlist"] = self.playlist
74
75                 self["PositionGauge"] = ServicePositionGauge(self.session.nav)
76
77                 self["currenttext"] = Label("")
78
79                 self["artisttext"] = Label(_("Artist:"))
80                 self["artist"] = Label("")
81                 self["titletext"] = Label(_("Title:"))
82                 self["title"] = Label("")
83                 self["albumtext"] = Label(_("Album:"))
84                 self["album"] = Label("")
85                 self["yeartext"] = Label(_("Year:"))
86                 self["year"] = Label("")
87                 self["genretext"] = Label(_("Genre:"))
88                 self["genre"] = Label("")
89                 self["coverArt"] = MediaPixmap()
90
91                 self.seek_target = None
92
93                 class MoviePlayerActionMap(NumberActionMap):
94                         def __init__(self, player, contexts = [ ], actions = { }, prio=0):
95                                 NumberActionMap.__init__(self, contexts, actions, prio)
96                                 self.player = player
97
98                         def action(self, contexts, action):
99                                 self.player.show()
100                                 return NumberActionMap.action(self, contexts, action)
101
102
103                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", 
104                         {
105                                 "ok": (self.ok, _("add file to playlist")),
106                                 "cancel": (self.exit, _("exit mediaplayer")),
107                         }, -2)
108
109                 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", 
110                         {
111                                 "play": (self.xplayEntry, _("play entry")),
112                                 "pause": (self.pauseEntry, _("pause")),
113                                 "stop": (self.stopEntry, _("stop entry")),
114                                 "previous": (self.previousMarkOrEntry, _("play from previous mark or playlist entry")),
115                                 "next": (self.nextMarkOrEntry, _("play from next mark or playlist entry")),
116                                 "menu": (self.showMenu, _("menu")),
117                                 "skipListbegin": (self.skip_listbegin, _("jump to listbegin")),
118                                 "skipListend": (self.skip_listend, _("jump to listend")),
119                                 "prevBouquet": (self.switchToPlayList, _("switch to playlist")),
120                                 "nextBouquet": (self.switchToFileList, _("switch to filelist")),
121                                 "delete": (self.deletePlaylistEntry, _("delete playlist entry")),
122                                 "shift_stop": (self.clear_playlist, _("clear playlist")),
123                                 "shift_record": (self.playlist.PlayListShuffle, _("shuffle playlist")),
124                         }, -2)
125
126                 self["InfobarEPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
127                         {
128                                 "showEventInfo": (self.showEventInformation, _("show event details")),
129                         })
130
131                 self["actions"] = MoviePlayerActionMap(self, ["DirectionActions"], 
132                 {
133                         "right": self.rightDown,
134                         "rightRepeated": self.doNothing,
135                         "rightUp": self.rightUp,
136                         "left": self.leftDown,
137                         "leftRepeated": self.doNothing,
138                         "leftUp": self.leftUp,
139
140                         "up": self.up,
141                         "upRepeated": self.up,
142                         "upUp": self.doNothing,
143                         "down": self.down,
144                         "downRepeated": self.down,
145                         "downUp": self.doNothing,
146                 }, -2)
147
148                 InfoBarSeek.__init__(self, actionmap = "MediaPlayerSeekActions")
149
150                 self.onClose.append(self.delMPTimer)
151                 self.onClose.append(self.__onClose)
152
153                 self.righttimer = False
154                 self.rightKeyTimer = eTimer()
155                 self.rightKeyTimer.callback.append(self.rightTimerFire)
156
157                 self.lefttimer = False
158                 self.leftKeyTimer = eTimer()
159                 self.leftKeyTimer.callback.append(self.leftTimerFire)
160
161                 self.currList = "filelist"
162
163                 self.coverArtFileName = ""
164
165                 self.playlistIOInternal = PlaylistIOInternal()
166                 list = self.playlistIOInternal.open(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
167                 if list:
168                         for x in list:
169                                 self.playlist.addFile(x.ref)
170                         self.playlist.updateList()
171
172         def doNothing(self):
173                 pass
174
175         def createSummary(self):
176                 return MediaPlayerLCDScreen
177
178         def exit(self):
179                 self.session.openWithCallback(self.exitCB, MessageBox, _("Do you really want to exit?"), timeout=5)
180
181         def exitCB(self, answer):
182                 if answer == True:
183                         self.playlistIOInternal.clear()
184                         for x in self.playlist.list:
185                                 self.playlistIOInternal.addService(ServiceReference(x[0]))
186                         self.playlistIOInternal.save(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
187                         self.close()
188
189         def checkSkipShowHideLock(self):
190                 self.updatedSeekState()
191
192         def doEofInternal(self, playing):
193                 if playing:
194                         self.nextEntry()
195                 else:
196                         self.show()
197
198         def __onClose(self):
199                 self.session.nav.playService(self.oldService)
200
201         def delMPTimer(self):
202                 del self.rightKeyTimer
203                 del self.leftKeyTimer
204
205         def readTitleInformation(self):
206                 currPlay = self.session.nav.getCurrentService()
207                 if currPlay is not None:
208                         stitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
209                         if stitle == "":
210                                 stitle = currPlay.info().getName().split('/')[-1]
211
212                         self.updateMusicInformation( artist = currPlay.info().getInfoString(iServiceInformation.sArtist),
213                                                                                  title = stitle,
214                                                                                  album = currPlay.info().getInfoString(iServiceInformation.sAlbum),
215                                                                                  genre = currPlay.info().getInfoString(iServiceInformation.sGenre),
216                                                                                  clear = True)
217                 else:
218                         self.updateMusicInformation()
219
220         def updateMusicInformation(self, artist = "", title = "", album = "", year = "", genre = "", clear = False):
221                 self.updateSingleMusicInformation("artist", artist, clear)
222                 self.updateSingleMusicInformation("title", title, clear)
223                 self.updateSingleMusicInformation("album", album, clear)
224                 self.updateSingleMusicInformation("year", year, clear)
225                 self.updateSingleMusicInformation("genre", genre, clear)
226
227         def updateSingleMusicInformation(self, name, info, clear):
228                 if info != "" or clear:
229                         if self[name].getText() != info:
230                                 self[name].setText(info)
231
232         def updateCoverArtPixmap(self, path):
233                 while not path.endswith("/"):
234                         path = path[:-1]
235                 pngname = path + "folder.png"
236                 
237                 if not os_path.exists(pngname):
238                         pngname = self["coverArt"].default_pixmap
239                 if self.coverArtFileName != pngname:
240                         self.coverArtFileName = pngname
241                         self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
242
243         def leftDown(self):
244                 self.lefttimer = True
245                 self.leftKeyTimer.start(1000)
246
247         def rightDown(self):
248                 self.righttimer = True
249                 self.rightKeyTimer.start(1000)
250
251         def leftUp(self):
252                 if self.lefttimer:
253                         self.leftKeyTimer.stop()
254                         self.lefttimer = False
255                         self[self.currList].pageUp()
256                         self.updateCurrentInfo()
257
258         def rightUp(self):
259                 if self.righttimer:
260                         self.rightKeyTimer.stop()
261                         self.righttimer = False
262                         self[self.currList].pageDown()
263                         self.updateCurrentInfo()
264
265         def leftTimerFire(self):
266                 self.leftKeyTimer.stop()
267                 self.lefttimer = False
268                 self.switchToFileList()
269
270         def rightTimerFire(self):
271                 self.rightKeyTimer.stop()
272                 self.righttimer = False
273                 self.switchToPlayList()
274
275         def switchToFileList(self):
276                 self.currList = "filelist"
277                 self.filelist.selectionEnabled(1)
278                 self.playlist.selectionEnabled(0)
279                 self.updateCurrentInfo()
280
281         def switchToPlayList(self):
282                 if len(self.playlist) != 0:
283                         self.currList = "playlist"
284                         self.filelist.selectionEnabled(0)
285                         self.playlist.selectionEnabled(1)
286                         self.updateCurrentInfo()
287
288         def up(self):
289                 self[self.currList].up()
290                 self.updateCurrentInfo()
291
292         def down(self):
293                 self[self.currList].down()
294                 self.updateCurrentInfo()
295
296         def showAfterSeek(self):
297                 self.show()
298
299         def showAfterCuesheetOperation(self):
300                 self.show()
301
302         def hideAfterResume(self):
303                 self.hide()
304
305         # FIXME: maybe this code can be optimized 
306         def updateCurrentInfo(self):
307                 text = ""
308                 if self.currList == "filelist":
309                         idx = self.filelist.getSelectionIndex()
310                         r = self.filelist.list[idx]
311                         text = r[1][7]
312                         if r[0][1] == True:
313                                 if len(text) < 2:
314                                         text += " "
315                                 if text[:2] != "..":
316                                         text = "/" + text
317                         self.summaries.setText(text,1)
318
319                         idx += 1
320                         if idx < len(self.filelist.list):
321                                 r = self.filelist.list[idx]
322                                 text = r[1][7]
323                                 if r[0][1] == True:
324                                         text = "/" + text
325                                 self.summaries.setText(text,3)
326                         else:
327                                 self.summaries.setText(" ",3)
328
329                         idx += 1
330                         if idx < len(self.filelist.list):
331                                 r = self.filelist.list[idx]
332                                 text = r[1][7]
333                                 if r[0][1] == True:
334                                         text = "/" + text
335                                 self.summaries.setText(text,4)
336                         else:
337                                 self.summaries.setText(" ",4)
338
339                         text = ""
340                         if not self.filelist.canDescent():
341                                 r = self.filelist.getServiceRef()
342                                 if r is None:
343                                         return
344                                 text = r.getPath()
345                                 self["currenttext"].setText(os_path.basename(text))
346
347                 if self.currList == "playlist":
348                         t = self.playlist.getSelection()
349                         if t is None:
350                                 return
351                         #display current selected entry on LCD
352                         text = t.getPath()
353                         text = text.split('/')[-1]
354                         self.summaries.setText(text,1)
355                         self["currenttext"].setText(text)
356                         idx = self.playlist.getSelectionIndex()
357                         idx += 1
358                         if idx < len(self.playlist):
359                                 currref = self.playlist.getServiceRefList()[idx]
360                                 text = currref.getPath()
361                                 text = text.split('/')[-1]
362                                 self.summaries.setText(text,3)
363                         else:
364                                 self.summaries.setText(" ",3)
365
366                         idx += 1
367                         if idx < len(self.playlist):
368                                 currref = self.playlist.getServiceRefList()[idx]
369                                 text = currref.getPath()
370                                 text = text.split('/')[-1]
371                                 self.summaries.setText(text,4)
372                         else:
373                                 self.summaries.setText(" ",4)
374
375         def ok(self):
376                 if self.currList == "filelist":
377                         if self.filelist.canDescent():
378                                 self.filelist.descent()
379                                 self.updateCurrentInfo()
380                         else:
381                                 self.copyFile()
382
383                 if self.currList == "playlist":
384                         selection = self["playlist"].getSelection()
385                         self.changeEntry(self.playlist.getSelectionIndex())
386
387         def showMenu(self):
388                 menu = []
389                 if self.currList == "filelist":
390                         if self.filelist.canDescent():
391                                 menu.append((_("add directory to playlist"), "copydir"))
392                         else:
393                                 menu.append((_("add files to playlist"), "copyfiles"))
394                         menu.append((_("switch to playlist"), "playlist"))
395                 else:
396                         menu.append((_("switch to filelist"), "filelist"))
397
398                         menu.append((_("shuffle playlist"), "shuffle"))
399
400                         menu.append((_("delete"), "delete"))
401                         menu.append((_("clear playlist"), "clear"))
402                 menu.append((_("hide player"), "hide"));
403                 menu.append((_("save playlist"), "saveplaylist"));
404                 menu.append((_("load playlist"), "loadplaylist"));
405                 menu.append((_("delete saved playlist"), "deleteplaylist"));
406                 self.session.openWithCallback(self.menuCallback, ChoiceBox, title="", list=menu)
407
408         def menuCallback(self, choice):
409                 if choice is None:
410                         return
411
412                 if choice[1] == "copydir":
413                         self.copyDirectory(self.filelist.getSelection()[0])
414                 elif choice[1] == "copyfiles":
415                         self.stopEntry()
416                         self.playlist.clear()
417                         self.copyDirectory(os_path.dirname(self.filelist.getSelection()[0].getPath()) + "/", recursive = False)
418                         self.playServiceRefEntry(self.filelist.getServiceRef())
419                 elif choice[1] == "playlist":
420                         self.switchToPlayList()
421                 elif choice[1] == "filelist":
422                         self.switchToFileList()
423                 elif choice[1] == "delete":
424                         if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
425                                 self.stopEntry()
426                         self.deleteEntry()
427                 elif choice[1] == "clear":
428                         self.stopEntry()
429                         self.playlist.clear()
430                         self.switchToFileList()
431                 elif choice[1] == "hide":
432                         self.hide()
433                 elif choice[1] == "saveplaylist":
434                         self.save_playlist()
435                 elif choice[1] == "loadplaylist":
436                         self.load_playlist()
437                 elif choice[1] == "deleteplaylist":
438                         self.delete_saved_playlist()
439                 elif choice[1] == "shuffle":
440                         self.playlist.PlayListShuffle()
441
442
443         def showEventInformation(self):
444                 from Screens.EventView import EventViewSimple
445                 from ServiceReference import ServiceReference
446                 evt = self[self.currList].getCurrentEvent()
447                 if evt:
448                         self.session.open(EventViewSimple, evt, ServiceReference(self.getCurrent()))
449
450         # also works on filelist (?)
451         def getCurrent(self):
452                 return self["playlist"].getCurrent()
453
454         def deletePlaylistEntry(self):
455                 if self.currList == "playlist":
456                         if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
457                                 self.stopEntry()
458                         self.deleteEntry()
459
460         def skip_listbegin(self):
461                 if self.currList == "filelist":
462                         self.filelist.moveToIndex(0)
463                 else:
464                         self.playlist.moveToIndex(0)
465                 self.updateCurrentInfo()
466
467         def skip_listend(self):
468                 if self.currList == "filelist":
469                         idx = len(self.filelist.list)
470                         self.filelist.moveToIndex(idx - 1)
471                 else:
472                         self.playlist.moveToIndex(len(self.playlist)-1)
473                 self.updateCurrentInfo()
474
475         def save_playlist(self):
476                 self.session.openWithCallback(self.save_playlist2,InputBox, title=_("Please enter filename (empty = use current date)"),windowTitle = _("Save Playlist"))
477
478         def save_playlist2(self, name):
479                 if name is not None:
480                         name = name.strip()
481                         if name == "":
482                                 name = strftime("%y%m%d_%H%M%S")
483                         name += ".e2pls"
484                         self.playlistIOInternal.clear()
485                         for x in self.playlist.list:
486                                 self.playlistIOInternal.addService(ServiceReference(x[0]))
487                         self.playlistIOInternal.save(resolveFilename(SCOPE_PLAYLIST) + name)
488
489         def load_playlist(self):
490                 listpath = []
491                 playlistdir = resolveFilename(SCOPE_PLAYLIST)
492                 try:
493                         for i in os_listdir(playlistdir):
494                                 listpath.append((i,playlistdir + i))
495                 except IOError,e:
496                         print "Error while scanning subdirs ",e
497                 self.session.openWithCallback(self.PlaylistSelected, ChoiceBox, title=_("Please select a playlist..."), list = listpath)
498
499         def PlaylistSelected(self,path):
500                 if path is not None:
501                         self.clear_playlist()
502                         self.playlistIOInternal = PlaylistIOInternal()
503                         list = self.playlistIOInternal.open(path[1])
504                         if list:
505                                 for x in list:
506                                         self.playlist.addFile(x.ref)
507                                 self.playlist.updateList()
508
509         def delete_saved_playlist(self):
510                 listpath = []
511                 playlistdir = resolveFilename(SCOPE_PLAYLIST)
512                 try:
513                         for i in os_listdir(playlistdir):
514                                 listpath.append((i,playlistdir + i))
515                 except IOError,e:
516                         print "Error while scanning subdirs ",e
517                 self.session.openWithCallback(self.DeletePlaylistSelected, ChoiceBox, title=_("Please select a playlist to delete..."), list = listpath)
518
519         def DeletePlaylistSelected(self,path):
520                 if path is not None:
521                         self.delname = path[1]
522                         self.session.openWithCallback(self.deleteConfirmed, MessageBox, _("Do you really want to delete %s?") % (path[1]))
523
524         def deleteConfirmed(self, confirmed):
525                 if confirmed:
526                         os_remove(self.delname)
527
528         def clear_playlist(self):
529                 self.stopEntry()
530                 self.playlist.clear()
531                 self.switchToFileList()
532
533         def copyDirectory(self, directory, recursive = True):
534                 print "copyDirectory", directory
535                 filelist = FileList(directory, useServiceRef = True, isTop = True)
536
537                 for x in filelist.getFileList():
538                         if x[0][1] == True: #isDir
539                                 if recursive:
540                                         self.copyDirectory(x[0][0])
541                         else:
542                                 self.playlist.addFile(x[0][0])
543                 self.playlist.updateList()
544
545         def copyFile(self):
546                 if self.filelist.getServiceRef().type == 4098: # playlist
547                         ServiceRef = self.filelist.getServiceRef()
548                         extension = ServiceRef.getPath()[ServiceRef.getPath().rfind('.') + 1:]
549                         print "extension:", extension
550                         if self.playlistparsers.has_key(extension):
551                                 playlist = self.playlistparsers[extension]()
552                                 list = playlist.open(ServiceRef.getPath())
553                                 for x in list:
554                                         self.playlist.addFile(x.ref)
555                 else:
556                         self.playlist.addFile(self.filelist.getServiceRef())
557                         self.playlist.updateList()
558                         if len(self.playlist) == 1:
559                                 self.changeEntry(0)
560
561         def addPlaylistParser(self, parser, extension):
562                 self.playlistparsers[extension] = parser
563
564         def nextEntry(self):
565                 next = self.playlist.getCurrentIndex() + 1
566                 if next < len(self.playlist):
567                         self.changeEntry(next)
568
569         def nextMarkOrEntry(self):
570                 if not self.jumpPreviousNextMark(lambda x: x):
571                         next = self.playlist.getCurrentIndex() + 1
572                         if next < len(self.playlist):
573                                 self.changeEntry(next)
574                         else:
575                                 self.doSeek(-1)
576
577         def previousMarkOrEntry(self):
578                 if not self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True):
579                         next = self.playlist.getCurrentIndex() - 1
580                         if next >= 0:
581                                 self.changeEntry(next)
582
583         def deleteEntry(self):
584                 self.playlist.deleteFile(self.playlist.getSelectionIndex())
585                 self.playlist.updateList()
586                 if len(self.playlist) == 0:
587                         self.switchToFileList()
588
589         def changeEntry(self, index):
590                 self.playlist.setCurrentPlaying(index)
591                 self.playEntry()
592
593         def playServiceRefEntry(self, serviceref):
594                 serviceRefList = self.playlist.getServiceRefList()
595                 for count in range(len(serviceRefList)):
596                         if serviceRefList[count] == serviceref:
597                                 self.changeEntry(count)
598                                 break
599                         
600         def xplayEntry(self):
601                 if self.currList == "playlist":
602                         self.playEntry()
603                 else:
604                         self.stopEntry()
605                         self.playlist.clear()
606                         sel = self.filelist.getSelection()
607                         if sel:
608                                 if sel[1]: # can descent
609                                         # add directory to playlist
610                                         self.copyDirectory(sel[0])
611                                 else:
612                                         # add files to playlist
613                                         self.copyDirectory(os_path.dirname(sel[0].getPath()) + "/", recursive = False)
614                         if len(self.playlist) > 0:
615                                 self.changeEntry(0)
616         
617         def playEntry(self):
618                 if len(self.playlist.getServiceRefList()):
619                         needsInfoUpdate = False
620                         currref = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()]
621                         if self.session.nav.getCurrentlyPlayingServiceReference() is None or currref != self.session.nav.getCurrentlyPlayingServiceReference():
622                                 self.session.nav.playService(self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()])
623                                 info = eServiceCenter.getInstance().info(currref)
624                                 description = info and info.getInfoString(currref, iServiceInformation.sDescription) or ""
625                                 self["title"].setText(description)
626                                 # display just playing musik on LCD
627                                 idx = self.playlist.getCurrentIndex()
628                                 currref = self.playlist.getServiceRefList()[idx]
629                                 text = currref.getPath()
630                                 text = text.split('/')[-1]
631                                 text = ">"+text
632                                 ext = text[-3:].lower()
633
634                                 # FIXME: the information if the service contains video (and we should hide our window) should com from the service instead 
635                                 if ext not in ["mp3", "wav", "ogg"]:
636                                         self.hide()
637                                 else:
638                                         needsInfoUpdate = True
639                                 self.summaries.setText(text,1)
640
641                                 # get the next two entries
642                                 idx += 1
643                                 if idx < len(self.playlist):
644                                         currref = self.playlist.getServiceRefList()[idx]
645                                         text = currref.getPath()
646                                         text = text.split('/')[-1]
647                                         self.summaries.setText(text,3)
648                                 else:
649                                         self.summaries.setText(" ",3)
650
651                                 idx += 1
652                                 if idx < len(self.playlist):
653                                         currref = self.playlist.getServiceRefList()[idx]
654                                         text = currref.getPath()
655                                         text = text.split('/')[-1]
656                                         self.summaries.setText(text,4)
657                                 else:
658                                         self.summaries.setText(" ",4)
659                         else:
660                                 idx = self.playlist.getCurrentIndex()
661                                 currref = self.playlist.getServiceRefList()[idx]
662                                 text = currref.getPath()
663                                 ext = text[-3:].lower()
664                                 if ext not in ["mp3", "wav", "ogg"]:
665                                         self.hide()
666                                 else:
667                                         needsInfoUpdate = True
668
669                         self.unPauseService()
670                         if needsInfoUpdate == True:
671                                 self.updateCoverArtPixmap(currref.getPath())
672                         else:
673                                 pngname = self["coverArt"].default_pixmap
674                                 self.coverArtFileName = pngname
675                                 self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
676                         self.readTitleInformation()
677
678         def updatedSeekState(self):
679                 if self.seekstate == self.SEEK_STATE_PAUSE:
680                         self.playlist.pauseFile()
681                 elif self.seekstate == self.SEEK_STATE_PLAY:
682                         self.playlist.playFile()
683                 elif self.isStateForward(self.seekstate):
684                         self.playlist.forwardFile()
685                 elif self.isStateBackward(self.seekstate):
686                         self.playlist.rewindFile()
687
688         def pauseEntry(self):
689                 self.pauseService()
690                 self.show()
691
692         def stopEntry(self):
693                 self.playlist.stopFile()
694                 self.session.nav.playService(None)
695                 self.updateMusicInformation(clear=True)
696                 self.show()
697
698         def unPauseService(self):
699                 self.setSeekState(self.SEEK_STATE_PLAY)
700
701
702 class MediaPlayerLCDScreen(Screen):
703         skin = """
704         <screen position="0,0" size="132,64" title="LCD Text">
705                 <widget name="text1" position="4,0" size="132,35" font="Regular;16"/>
706                 <widget name="text3" position="4,36" size="132,14" font="Regular;10"/>
707                 <widget name="text4" position="4,49" size="132,14" font="Regular;10"/>
708         </screen>"""
709
710         def __init__(self, session, parent):
711                 Screen.__init__(self, session)
712                 self["text1"] = Label("Mediaplayer")
713                 self["text3"] = Label("")
714                 self["text4"] = Label("")
715
716         def setText(self, text, line):
717                 print "lcd set text:", text, line
718                 if len(text) > 10:
719                         if text[-4:] == ".mp3":
720                                 text = text[:-4]
721                 textleer = "    "
722                 text = text + textleer*10
723                 if line == 1:
724                         self["text1"].setText(text)
725                 elif line == 3:
726                         self["text3"].setText(text)
727                 elif line == 4:
728                         self["text4"].setText(text)
729
730 def main(session, **kwargs):
731         session.open(MediaPlayer)
732
733 def menu(menuid, **kwargs):
734         if menuid == "mainmenu":
735                 return [(_("Media player"), main, "media_player", 45)]
736         return []
737
738 def filescan_open(list, session, **kwargs):
739         from enigma import eServiceReference
740
741         mp = session.open(MediaPlayer)
742
743         mp.switchToPlayList()
744         for file in list:
745                 ref = eServiceReference(4097, 0, file.path)
746                 mp.playlist.addFile(ref)
747
748         # TODO: rather play first than last file?
749         mp.playServiceRefEntry(ref)
750         mp.playlist.updateList()
751
752 def filescan(**kwargs):
753         from Components.Scanner import Scanner, ScanPath
754         return [
755                 Scanner(mimetypes = ["video/mpeg"],
756                         paths_to_scan =
757                                 [
758                                         ScanPath(path = "", with_subdirs = False),
759                                 ],
760                         name = "Movie",
761                         description = "View Movies...",
762                         openfnc = filescan_open,
763                 ),
764                 Scanner(mimetypes = ["audio/mpeg", "audio/x-wav", "application/ogg"],
765                         paths_to_scan =
766                                 [
767                                         ScanPath(path = "", with_subdirs = False),
768                                 ],
769                         name = "Music",
770                         description = "Play Music...",
771                         openfnc = filescan_open,
772                 )
773         ]
774
775 from Plugins.Plugin import PluginDescriptor
776 def Plugins(**kwargs):
777         return [
778                 PluginDescriptor(name = "MediaPlayer", description = "Play back media files", where = PluginDescriptor.WHERE_MENU, fnc = menu),
779                 PluginDescriptor(name = "MediaPlayer", where = PluginDescriptor.WHERE_FILESCAN, fnc = filescan)
780         ]