1 from os import path as os_path, remove as os_remove, listdir as os_listdir, popen
2 from time import strftime
3 from enigma import iPlayableService, 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,MultiPixmap
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 ServiceEventTracker, 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
23 class MyPlayList(PlayList):
25 PlayList.__init__(self)
27 def PlayListShuffle(self):
28 random.shuffle(self.list)
29 self.l.setList(self.list)
31 self.oldCurrPlaying = -1
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
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)
45 class MediaPlayer(Screen, InfoBarBase, InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications, HelpableScreen):
47 ENABLE_RESUME_SUPPORT = True
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)
57 self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
58 self.session.nav.stopService()
60 self.playlistparsers = {}
61 self.addPlaylistParser(PlaylistIOM3U, "m3u")
62 self.addPlaylistParser(PlaylistIOPLS, "pls")
63 self.addPlaylistParser(PlaylistIOInternal, "e2pls")
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|avi|mkv)", useServiceRef = True, additionalExtensions = "4098:m3u 4098:e2pls 4098:pls")
67 self["filelist"] = self.filelist
69 self.playlist = MyPlayList()
70 #self.playlist = PlayList()
71 self.is_closing = False
73 self["playlist"] = self.playlist
75 self["PositionGauge"] = ServicePositionGauge(self.session.nav)
77 self["currenttext"] = Label("")
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 self["repeat"] = MultiPixmap()
93 self.seek_target = None
95 class MoviePlayerActionMap(NumberActionMap):
96 def __init__(self, player, contexts = [ ], actions = { }, prio=0):
97 NumberActionMap.__init__(self, contexts, actions, prio)
100 def action(self, contexts, action):
102 return NumberActionMap.action(self, contexts, action)
105 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
107 "ok": (self.ok, _("add file to playlist")),
108 "cancel": (self.exit, _("exit mediaplayer")),
111 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions",
113 "play": (self.xplayEntry, _("play entry")),
114 "pause": (self.pauseEntry, _("pause")),
115 "stop": (self.stopEntry, _("stop entry")),
116 "previous": (self.previousMarkOrEntry, _("play from previous mark or playlist entry")),
117 "next": (self.nextMarkOrEntry, _("play from next mark or playlist entry")),
118 "menu": (self.showMenu, _("menu")),
119 "skipListbegin": (self.skip_listbegin, _("jump to listbegin")),
120 "skipListend": (self.skip_listend, _("jump to listend")),
121 "prevBouquet": (self.switchToPlayList, _("switch to playlist")),
122 "nextBouquet": (self.switchToFileList, _("switch to filelist")),
123 "delete": (self.deletePlaylistEntry, _("delete playlist entry")),
124 "shift_stop": (self.clear_playlist, _("clear playlist")),
125 "shift_record": (self.playlist.PlayListShuffle, _("shuffle playlist")),
128 self["InfobarEPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
130 "showEventInfo": (self.showEventInformation, _("show event details")),
133 self["actions"] = MoviePlayerActionMap(self, ["DirectionActions"],
135 "right": self.rightDown,
136 "rightRepeated": self.doNothing,
137 "rightUp": self.rightUp,
138 "left": self.leftDown,
139 "leftRepeated": self.doNothing,
140 "leftUp": self.leftUp,
143 "upRepeated": self.up,
144 "upUp": self.doNothing,
146 "downRepeated": self.down,
147 "downUp": self.doNothing,
150 InfoBarSeek.__init__(self, actionmap = "MediaPlayerSeekActions")
152 self.onClose.append(self.delMPTimer)
153 self.onClose.append(self.__onClose)
155 self.righttimer = False
156 self.rightKeyTimer = eTimer()
157 self.rightKeyTimer.callback.append(self.rightTimerFire)
159 self.lefttimer = False
160 self.leftKeyTimer = eTimer()
161 self.leftKeyTimer.callback.append(self.leftTimerFire)
163 self.currList = "filelist"
165 self.coverArtFileName = ""
166 self.isAudioCD = False
167 self.AudioCD_albuminfo = {}
168 self.savePlaylistOnExit = True
170 self.playlistIOInternal = PlaylistIOInternal()
171 list = self.playlistIOInternal.open(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
174 self.playlist.addFile(x.ref)
175 self.playlist.updateList()
177 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
179 iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
180 iPlayableService.evUser+11: self.__evDecodeError
186 def createSummary(self):
187 return MediaPlayerLCDScreen
190 self.session.openWithCallback(self.exitCB, MessageBox, _("Do you really want to exit?"), timeout=5)
192 def exitCB(self, answer):
194 self.playlistIOInternal.clear()
195 for x in self.playlist.list:
196 self.playlistIOInternal.addService(ServiceReference(x[0]))
197 if self.savePlaylistOnExit:
198 self.playlistIOInternal.save(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
201 def checkSkipShowHideLock(self):
202 self.updatedSeekState()
204 def doEofInternal(self, playing):
211 self.session.nav.playService(self.oldService)
213 def __evUpdatedInfo(self):
214 currPlay = self.session.nav.getCurrentService()
215 currenttitle = currPlay.info().getInfo(iServiceInformation.sCurrentTitle)
216 totaltitles = currPlay.info().getInfo(iServiceInformation.sTotalTitles)
217 sTitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
218 print "[__evUpdatedInfo] title %d of %d (%s)" % (currenttitle, totaltitles, sTitle)
219 self.readTitleInformation()
221 def __evDecodeError(self):
222 currPlay = self.session.nav.getCurrentService()
223 sVideoType = currPlay.info().getInfoString(iServiceInformation.sVideoType)
224 print "[__evDecodeError] video-codec %s can't be decoded by hardware" % (sVideoType)
225 self.session.open(MessageBox, _("This Dreambox can't decode %s video streams!") % sVideoType, type = MessageBox.TYPE_INFO,timeout = 10 )
227 def delMPTimer(self):
228 del self.rightKeyTimer
229 del self.leftKeyTimer
231 def readTitleInformation(self):
232 currPlay = self.session.nav.getCurrentService()
233 if currPlay is not None:
234 sTitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
235 sAlbum = currPlay.info().getInfoString(iServiceInformation.sAlbum)
236 sGenre = currPlay.info().getInfoString(iServiceInformation.sGenre)
237 sArtist = currPlay.info().getInfoString(iServiceInformation.sArtist)
241 if not self.isAudioCD:
242 sTitle = currPlay.info().getName().split('/')[-1]
244 sTitle = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()].getName()
246 if self.AudioCD_albuminfo:
247 if sAlbum == "" and "title" in self.AudioCD_albuminfo:
248 sAlbum = self.AudioCD_albuminfo["title"]
249 if sGenre == "" and "genre" in self.AudioCD_albuminfo:
250 sGenre = self.AudioCD_albuminfo["genre"]
251 if sArtist == "" and "artist" in self.AudioCD_albuminfo:
252 sArtist = self.AudioCD_albuminfo["artist"]
253 if "year" in self.AudioCD_albuminfo:
254 sYear = self.AudioCD_albuminfo["year"]
256 self.updateMusicInformation( sArtist, sTitle, sAlbum, sYear, sGenre, clear = True )
258 self.updateMusicInformation()
260 def updateMusicInformation(self, artist = "", title = "", album = "", year = "", genre = "", clear = False):
261 self.updateSingleMusicInformation("artist", artist, clear)
262 self.updateSingleMusicInformation("title", title, clear)
263 self.updateSingleMusicInformation("album", album, clear)
264 self.updateSingleMusicInformation("year", year, clear)
265 self.updateSingleMusicInformation("genre", genre, clear)
267 def updateSingleMusicInformation(self, name, info, clear):
268 if info != "" or clear:
269 if self[name].getText() != info:
270 self[name].setText(info)
272 def updateCoverArtPixmap(self, path):
273 while not path.endswith("/"):
275 pngname = path + "folder.png"
277 if not os_path.exists(pngname):
278 pngname = self["coverArt"].default_pixmap
279 if self.coverArtFileName != pngname:
280 self.coverArtFileName = pngname
281 self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
284 self.lefttimer = True
285 self.leftKeyTimer.start(1000)
288 self.righttimer = True
289 self.rightKeyTimer.start(1000)
293 self.leftKeyTimer.stop()
294 self.lefttimer = False
295 self[self.currList].pageUp()
296 self.updateCurrentInfo()
300 self.rightKeyTimer.stop()
301 self.righttimer = False
302 self[self.currList].pageDown()
303 self.updateCurrentInfo()
305 def leftTimerFire(self):
306 self.leftKeyTimer.stop()
307 self.lefttimer = False
308 self.switchToFileList()
310 def rightTimerFire(self):
311 self.rightKeyTimer.stop()
312 self.righttimer = False
313 self.switchToPlayList()
315 def switchToFileList(self):
316 self.currList = "filelist"
317 self.filelist.selectionEnabled(1)
318 self.playlist.selectionEnabled(0)
319 self.updateCurrentInfo()
321 def switchToPlayList(self):
322 if len(self.playlist) != 0:
323 self.currList = "playlist"
324 self.filelist.selectionEnabled(0)
325 self.playlist.selectionEnabled(1)
326 self.updateCurrentInfo()
329 self[self.currList].up()
330 self.updateCurrentInfo()
333 self[self.currList].down()
334 self.updateCurrentInfo()
336 def showAfterSeek(self):
339 def showAfterCuesheetOperation(self):
342 def hideAfterResume(self):
345 def getIdentifier(self, ref):
350 return text.split('/')[-1]
352 # FIXME: maybe this code can be optimized
353 def updateCurrentInfo(self):
355 if self.currList == "filelist":
356 idx = self.filelist.getSelectionIndex()
357 r = self.filelist.list[idx]
364 self.summaries.setText(text,1)
367 if idx < len(self.filelist.list):
368 r = self.filelist.list[idx]
372 self.summaries.setText(text,3)
374 self.summaries.setText(" ",3)
377 if idx < len(self.filelist.list):
378 r = self.filelist.list[idx]
382 self.summaries.setText(text,4)
384 self.summaries.setText(" ",4)
387 if not self.filelist.canDescent():
388 r = self.filelist.getServiceRef()
392 self["currenttext"].setText(os_path.basename(text))
394 if self.currList == "playlist":
395 t = self.playlist.getSelection()
398 #display current selected entry on LCD
399 text = self.getIdentifier(t)
400 self.summaries.setText(text,1)
401 self["currenttext"].setText(text)
402 idx = self.playlist.getSelectionIndex()
404 if idx < len(self.playlist):
405 currref = self.playlist.getServiceRefList()[idx]
406 text = self.getIdentifier(currref)
407 self.summaries.setText(text,3)
409 self.summaries.setText(" ",3)
412 if idx < len(self.playlist):
413 currref = self.playlist.getServiceRefList()[idx]
414 text = self.getIdentifier(currref)
415 self.summaries.setText(text,4)
417 self.summaries.setText(" ",4)
420 if self.currList == "filelist":
421 if self.filelist.canDescent():
422 self.filelist.descent()
423 self.updateCurrentInfo()
427 if self.currList == "playlist":
428 selection = self["playlist"].getSelection()
429 self.changeEntry(self.playlist.getSelectionIndex())
433 if self.currList == "filelist":
434 if self.filelist.canDescent():
435 menu.append((_("add directory to playlist"), "copydir"))
437 menu.append((_("add files to playlist"), "copyfiles"))
438 menu.append((_("switch to playlist"), "playlist"))
440 menu.append((_("switch to filelist"), "filelist"))
442 menu.append((_("shuffle playlist"), "shuffle"))
444 menu.append((_("delete"), "delete"))
445 menu.append((_("clear playlist"), "clear"))
446 menu.append((_("hide player"), "hide"));
447 menu.append((_("save playlist"), "saveplaylist"));
448 menu.append((_("load playlist"), "loadplaylist"));
449 menu.append((_("delete saved playlist"), "deleteplaylist"));
450 menu.append((_("repeat playlist"), "repeat"));
451 self.session.openWithCallback(self.menuCallback, ChoiceBox, title="", list=menu)
453 def menuCallback(self, choice):
457 if choice[1] == "copydir":
458 self.copyDirectory(self.filelist.getSelection()[0])
459 elif choice[1] == "copyfiles":
461 self.playlist.clear()
462 self.copyDirectory(os_path.dirname(self.filelist.getSelection()[0].getPath()) + "/", recursive = False)
463 self.playServiceRefEntry(self.filelist.getServiceRef())
464 elif choice[1] == "playlist":
465 self.switchToPlayList()
466 elif choice[1] == "filelist":
467 self.switchToFileList()
468 elif choice[1] == "delete":
469 if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
472 elif choice[1] == "clear":
474 self.playlist.clear()
475 self.switchToFileList()
476 elif choice[1] == "hide":
478 elif choice[1] == "saveplaylist":
480 elif choice[1] == "loadplaylist":
482 elif choice[1] == "deleteplaylist":
483 self.delete_saved_playlist()
484 elif choice[1] == "shuffle":
485 self.playlist.PlayListShuffle()
486 elif choice[1] == "repeat":
487 if self.repeat == True:
489 self["repeat"].setPixmapNum(0)
492 self["repeat"].setPixmapNum(1)
494 def showEventInformation(self):
495 from Screens.EventView import EventViewSimple
496 from ServiceReference import ServiceReference
497 evt = self[self.currList].getCurrentEvent()
499 self.session.open(EventViewSimple, evt, ServiceReference(self.getCurrent()))
501 # also works on filelist (?)
502 def getCurrent(self):
503 return self["playlist"].getCurrent()
505 def deletePlaylistEntry(self):
506 if self.currList == "playlist":
507 if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
511 def skip_listbegin(self):
512 if self.currList == "filelist":
513 self.filelist.moveToIndex(0)
515 self.playlist.moveToIndex(0)
516 self.updateCurrentInfo()
518 def skip_listend(self):
519 if self.currList == "filelist":
520 idx = len(self.filelist.list)
521 self.filelist.moveToIndex(idx - 1)
523 self.playlist.moveToIndex(len(self.playlist)-1)
524 self.updateCurrentInfo()
526 def save_playlist(self):
527 self.session.openWithCallback(self.save_playlist2,InputBox, title=_("Please enter filename (empty = use current date)"),windowTitle = _("Save Playlist"))
529 def save_playlist2(self, name):
533 name = strftime("%y%m%d_%H%M%S")
535 self.playlistIOInternal.clear()
536 for x in self.playlist.list:
537 self.playlistIOInternal.addService(ServiceReference(x[0]))
538 self.playlistIOInternal.save(resolveFilename(SCOPE_PLAYLIST) + name)
540 def load_playlist(self):
542 playlistdir = resolveFilename(SCOPE_PLAYLIST)
544 for i in os_listdir(playlistdir):
545 listpath.append((i,playlistdir + i))
547 print "Error while scanning subdirs ",e
548 self.session.openWithCallback(self.PlaylistSelected, ChoiceBox, title=_("Please select a playlist..."), list = listpath)
550 def PlaylistSelected(self,path):
552 self.clear_playlist()
553 self.playlistIOInternal = PlaylistIOInternal()
554 list = self.playlistIOInternal.open(path[1])
557 self.playlist.addFile(x.ref)
558 self.playlist.updateList()
560 def delete_saved_playlist(self):
562 playlistdir = resolveFilename(SCOPE_PLAYLIST)
564 for i in os_listdir(playlistdir):
565 listpath.append((i,playlistdir + i))
567 print "Error while scanning subdirs ",e
568 self.session.openWithCallback(self.DeletePlaylistSelected, ChoiceBox, title=_("Please select a playlist to delete..."), list = listpath)
570 def DeletePlaylistSelected(self,path):
572 self.delname = path[1]
573 self.session.openWithCallback(self.deleteConfirmed, MessageBox, _("Do you really want to delete %s?") % (path[1]))
575 def deleteConfirmed(self, confirmed):
577 os_remove(self.delname)
579 def clear_playlist(self):
581 self.playlist.clear()
582 self.switchToFileList()
584 def copyDirectory(self, directory, recursive = True):
585 print "copyDirectory", directory
586 filelist = FileList(directory, useServiceRef = True, isTop = True)
588 for x in filelist.getFileList():
589 if x[0][1] == True: #isDir
591 self.copyDirectory(x[0][0])
593 self.playlist.addFile(x[0][0])
594 self.playlist.updateList()
597 if self.filelist.getServiceRef().type == 4098: # playlist
598 ServiceRef = self.filelist.getServiceRef()
599 extension = ServiceRef.getPath()[ServiceRef.getPath().rfind('.') + 1:]
600 print "extension:", extension
601 if self.playlistparsers.has_key(extension):
602 playlist = self.playlistparsers[extension]()
603 list = playlist.open(ServiceRef.getPath())
605 self.playlist.addFile(x.ref)
607 self.playlist.addFile(self.filelist.getServiceRef())
608 self.playlist.updateList()
609 if len(self.playlist) == 1:
612 def addPlaylistParser(self, parser, extension):
613 self.playlistparsers[extension] = parser
616 next = self.playlist.getCurrentIndex() + 1
617 if next < len(self.playlist):
618 self.changeEntry(next)
619 elif ( len(self.playlist) > 0 ) and ( self.repeat == True ):
623 def nextMarkOrEntry(self):
624 if not self.jumpPreviousNextMark(lambda x: x):
625 next = self.playlist.getCurrentIndex() + 1
626 if next < len(self.playlist):
627 self.changeEntry(next)
631 def previousMarkOrEntry(self):
632 if not self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True):
633 next = self.playlist.getCurrentIndex() - 1
635 self.changeEntry(next)
637 def deleteEntry(self):
638 self.playlist.deleteFile(self.playlist.getSelectionIndex())
639 self.playlist.updateList()
640 if len(self.playlist) == 0:
641 self.switchToFileList()
643 def changeEntry(self, index):
644 self.playlist.setCurrentPlaying(index)
647 def playServiceRefEntry(self, serviceref):
648 serviceRefList = self.playlist.getServiceRefList()
649 for count in range(len(serviceRefList)):
650 if serviceRefList[count] == serviceref:
651 self.changeEntry(count)
654 def xplayEntry(self):
655 if self.currList == "playlist":
659 self.playlist.clear()
660 sel = self.filelist.getSelection()
662 if sel[1]: # can descent
663 # add directory to playlist
664 self.copyDirectory(sel[0])
666 # add files to playlist
667 self.copyDirectory(os_path.dirname(sel[0].getPath()) + "/", recursive = False)
668 if len(self.playlist) > 0:
672 if len(self.playlist.getServiceRefList()):
673 needsInfoUpdate = False
674 currref = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()]
675 if self.session.nav.getCurrentlyPlayingServiceReference() is None or currref != self.session.nav.getCurrentlyPlayingServiceReference():
676 self.session.nav.playService(self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()])
677 info = eServiceCenter.getInstance().info(currref)
678 description = info and info.getInfoString(currref, iServiceInformation.sDescription) or ""
679 self["title"].setText(description)
680 # display just playing musik on LCD
681 idx = self.playlist.getCurrentIndex()
682 currref = self.playlist.getServiceRefList()[idx]
683 text = self.getIdentifier(currref)
685 ext = text[-3:].lower()
687 # FIXME: the information if the service contains video (and we should hide our window) should com from the service instead
688 if ext not in ["mp3", "wav", "ogg"] and not self.isAudioCD:
691 needsInfoUpdate = True
692 self.summaries.setText(text,1)
694 # get the next two entries
696 if idx < len(self.playlist):
697 currref = self.playlist.getServiceRefList()[idx]
698 text = self.getIdentifier(currref)
699 self.summaries.setText(text,3)
701 self.summaries.setText(" ",3)
704 if idx < len(self.playlist):
705 currref = self.playlist.getServiceRefList()[idx]
706 text = self.getIdentifier(currref)
707 self.summaries.setText(text,4)
709 self.summaries.setText(" ",4)
711 idx = self.playlist.getCurrentIndex()
712 currref = self.playlist.getServiceRefList()[idx]
713 text = currref.getPath()
714 ext = text[-3:].lower()
715 if ext not in ["mp3", "wav", "ogg"] and not self.isAudioCD:
718 needsInfoUpdate = True
720 self.unPauseService()
721 if needsInfoUpdate == True:
722 self.updateCoverArtPixmap(currref.getPath())
724 pngname = self["coverArt"].default_pixmap
725 self.coverArtFileName = pngname
726 self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
727 self.readTitleInformation()
729 def updatedSeekState(self):
730 if self.seekstate == self.SEEK_STATE_PAUSE:
731 self.playlist.pauseFile()
732 elif self.seekstate == self.SEEK_STATE_PLAY:
733 self.playlist.playFile()
734 elif self.isStateForward(self.seekstate):
735 self.playlist.forwardFile()
736 elif self.isStateBackward(self.seekstate):
737 self.playlist.rewindFile()
739 def pauseEntry(self):
741 if self.seekstate == self.SEEK_STATE_PAUSE:
747 self.playlist.stopFile()
748 self.session.nav.playService(None)
749 self.updateMusicInformation(clear=True)
752 def unPauseService(self):
753 self.setSeekState(self.SEEK_STATE_PLAY)
755 class MediaPlayerLCDScreen(Screen):
757 <screen position="0,0" size="132,64" title="LCD Text">
758 <widget name="text1" position="4,0" size="132,35" font="Regular;16"/>
759 <widget name="text3" position="4,36" size="132,14" font="Regular;10"/>
760 <widget name="text4" position="4,49" size="132,14" font="Regular;10"/>
763 def __init__(self, session, parent):
764 Screen.__init__(self, session)
765 self["text1"] = Label("Mediaplayer")
766 self["text3"] = Label("")
767 self["text4"] = Label("")
769 def setText(self, text, line):
770 print "lcd set text:", text, line
772 if text[-4:] == ".mp3":
775 text = text + textleer*10
777 self["text1"].setText(text)
779 self["text3"].setText(text)
781 self["text4"].setText(text)
783 def main(session, **kwargs):
784 session.open(MediaPlayer)
786 def menu(menuid, **kwargs):
787 if menuid == "mainmenu":
788 return [(_("Media player"), main, "media_player", 45)]
791 def filescan_open(list, session, **kwargs):
792 from enigma import eServiceReference
794 mp = session.open(MediaPlayer)
796 mp.savePlaylistOnExit = False
799 if file.mimetype == "video/MP2T":
803 ref = eServiceReference(stype, 0, file.path)
804 mp.playlist.addFile(ref)
807 mp.switchToPlayList()
809 def audioCD_open(list, session, **kwargs):
810 from enigma import eServiceReference
812 mp = session.open(MediaPlayer)
815 mp.savePlaylistOnExit = False
819 ref = eServiceReference(4097, 0, file.path)
820 mp.playlist.addFile(ref)
821 from Plugins.Extensions.CDInfo.plugin import Query
826 mp.switchToPlayList()
828 def filescan(**kwargs):
829 from Components.Scanner import Scanner, ScanPath
831 Scanner(mimetypes = ["video/mpeg", "video/MP2T", "video/x-msvideo"],
834 ScanPath(path = "", with_subdirs = False),
837 description = "View Movies...",
838 openfnc = filescan_open,
840 Scanner(mimetypes = ["audio/mpeg", "audio/x-wav", "application/ogg"],
843 ScanPath(path = "", with_subdirs = False),
846 description = "Play Music...",
847 openfnc = filescan_open,
850 from Plugins.Extensions.CDInfo.plugin import Query
852 Scanner(mimetypes = ["audio/x-cda"],
855 ScanPath(path = "", with_subdirs = False),
858 description = "Play Audio-CD...",
859 openfnc = audioCD_open,
865 from Plugins.Plugin import PluginDescriptor
866 def Plugins(**kwargs):
868 PluginDescriptor(name = "MediaPlayer", description = "Play back media files", where = PluginDescriptor.WHERE_MENU, fnc = menu),
869 PluginDescriptor(name = "MediaPlayer", where = PluginDescriptor.WHERE_FILESCAN, fnc = filescan)