Index: /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/control =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/control (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/control (revision 8781) @@ -0,0 +1,10 @@ +Package: enigma2-plugin-swapplayers-mytube +Version: 1.0 +Architecture: sh4 +OE: MyTube +Section: players +Priority: optional +Maintainer: acid-burn@opendreambox.org +Homepage: http://www.aaf-digital.info +Source: http://www.aaf-digital.info +Description: MyTube Plugin for swapstick to view YouTube videos over internet! SWAPSTICK IS NEEDED! Index: /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/postinst =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/postinst (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/postinst (revision 8781) @@ -0,0 +1,7 @@ +#!/bin/sh +TMP=/tmp/.players +echo "successfully installed" +echo "syncing disk" +echo "please reboot your box so that the extension will be mounted..." +sync +exit 0 Index: /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/postrm =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/postrm (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/postrm (revision 8781) @@ -0,0 +1,9 @@ +#!/bin/sh +TMP=/tmp/.players + +rm -rf /var/swap/extensions/MyTube + +echo "successfully removed" +echo "syncing disk" +sync +exit 0 Index: /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/preinst =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/preinst (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/preinst (revision 8781) @@ -0,0 +1,39 @@ +#!/bin/sh +# +TMP=/tmp/.players +echo "syncing disk" +sync + +model=`cat /etc/model` + +echo"" +echo "Checking your Boxtype...." +echo "Some Plugins will not work correctly on your $model!" +echo "" +if [ "$model" = "" ]; then + echo "Sorry! This Plugin is not available for your $model because it will not work correctly!!!" + echo "Aborting installation..." + exit 1 +else + echo "Boxtype: $model OK" +fi + +echo "checking swapstick" +if [ ! -d /var/swap/extensions/ ]; then + echo "--------------------------" + echo "no swapstick found...." + echo "--------------------------" + exit 1 +fi +echo "swapstick found...." +echo "installing MyTube plugin to swapstick..." +echo "checking OS" +if [ `cat /etc/motd | grep AAF | grep M | grep rev | wc -l` -eq 0 ]; then + echo --------------------------- + echo DONT USE this IPK Package!! + echo --- + echo Only for AAF Image!! + echo --------------------------- + exit 1 +fi +exit 0 Index: /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/prerm =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/prerm (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/CONTROL/prerm (revision 8781) @@ -0,0 +1,6 @@ +#!/bin/sh +TMP=/tmp/.players +echo "syncing disk" +sync +echo "removing MyTube plugin from swapstick" +exit 0 Index: /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/LICENSE =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/LICENSE (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/LICENSE (revision 8781) @@ -0,0 +1,14 @@ +This plugin is licensed under the Creative Commons +Attribution-NonCommercial-ShareAlike 3.0 Unported +License. To view a copy of this license, visit +http://creativecommons.org/licenses/by-nc-sa/3.0/ or send a letter to Creative +Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA. + +Alternatively, this plugin may be distributed and executed on hardware which +is licensed by Dream Multimedia GmbH. + +This plugin is NOT free software. It is open source, you are allowed to +modify it (if you keep the license), but it may not be commercially +distributed other than under the conditions noted above. + +Special Thanks goes to Volker Christian (Volker.Christian@fh-hagenberg.at) for the great work on GoogleSuggestions Index: /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/MyTubeSearch.py =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/MyTubeSearch.py (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/MyTubeSearch.py (revision 8781) @@ -0,0 +1,677 @@ +from __init__ import _ +from MyTubeService import GoogleSuggestions +from Screens.Screen import Screen +from Screens.LocationBox import MovieLocationBox +from Components.config import config, Config, ConfigSelection, ConfigText, getConfigListEntry, ConfigSubsection, ConfigYesNo, ConfigIP, ConfigNumber,ConfigLocations +from Components.ConfigList import ConfigListScreen +from Components.config import KEY_DELETE, KEY_BACKSPACE, KEY_LEFT, KEY_RIGHT, KEY_HOME, KEY_END, KEY_TOGGLEOW, KEY_ASCII, KEY_TIMEOUT +from Components.ActionMap import ActionMap +from Components.Button import Button +from Components.Label import Label +from Components.ScrollLabel import ScrollLabel +from Components.Sources.List import List +from Components.Pixmap import Pixmap +from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest +from Components.Task import Task, Job, job_manager +from enigma import eListboxPythonMultiContent, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, gFont, eListbox,ePoint,eTimer +from Components.Task import job_manager +from Tools.Directories import pathExists, fileExists, resolveFilename, SCOPE_HDD +from threading import Thread +from threading import Condition + + +import urllib +from urllib import FancyURLopener + +class MyOpener(FancyURLopener): + version = 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12' + + +class ConfigTextWithGoogleSuggestions(ConfigText): + class SuggestionsThread(Thread): + def __init__(self, suggestionsService): + Thread.__init__(self) + self.suggestionsService = suggestionsService + self.value = None + self.running = True + self.condition = Condition() + + def run(self): + while self.running: + self.condition.acquire() + if self.value is None: + self.condition.wait() + value = self.value + self.value = None + self.condition.release() + if value is not None: + self.suggestionsService.getSuggestions(value) + + def stop(self): + self.running = False + self.condition.acquire() + self.condition.notify() + self.condition.release() + self.join() + + def getSuggestions(self, value): + self.condition.acquire() + self.value = value + self.condition.notify() + self.condition.release() + + def __init__(self, default = "", fixed_size = True, visible_width = False, threaded = False): + ConfigText.__init__(self, default, fixed_size, visible_width) + self.suggestions = GoogleSuggestions(self.propagateSuggestions, ds = "yt", hl = "en") + self.suggestionsThread = None + self.threaded = threaded + self.suggestionsListActivated = False + + def propagateSuggestions(self, suggestionsList): + if self.suggestionsWindow: + self.suggestionsWindow.update(suggestionsList) + + def getSuggestions(self): + if self.suggestionsThread is not None: + self.suggestionsThread.getSuggestions(self.value) + else: + self.suggestions.getSuggestions(self.value) + + def handleKey(self, key): + if not self.suggestionsListActivated: + ConfigText.handleKey(self, key) + if key in [KEY_DELETE, KEY_BACKSPACE, KEY_ASCII, KEY_TIMEOUT]: + self.getSuggestions() + + def onSelect(self, session): + if self.threaded: + if self.suggestionsThread is not None: + self.suggestionsThread.stop() + self.suggestionsThread = ConfigTextWithGoogleSuggestions.SuggestionsThread(self.suggestions) + self.suggestionsThread.start() + else: + self.suggestionsThread = None + ConfigText.onSelect(self, session) + if session is not None: + self.suggestionsWindow = session.instantiateDialog(MyTubeSuggestionsListScreen, self) + self.suggestionsWindow.deactivate() + self.suggestionsWindow.hide() + self.suggestions.getSuggestions(self.value) + + def onDeselect(self, session): + if self.suggestionsThread is not None: + self.suggestionsThread.stop() + ConfigText.onDeselect(self, session) + if self.suggestionsWindow: + session.deleteDialog(self.suggestionsWindow) + self.suggestionsWindow = None + + def suggestionListUp(self): + if self.suggestionsWindow.getlistlenght() > 0: + self.value = self.suggestionsWindow.up() + + def suggestionListDown(self): + if self.suggestionsWindow.getlistlenght() > 0: + self.value = self.suggestionsWindow.down() + + def suggestionListPageDown(self): + if self.suggestionsWindow.getlistlenght() > 0: + self.value = self.suggestionsWindow.pageDown() + + def suggestionListPageUp(self): + if self.suggestionsWindow.getlistlenght() > 0: + self.value = self.suggestionsWindow.pageUp() + + def activateSuggestionList(self): + ret = False + if self.suggestionsWindow is not None and self.suggestionsWindow.shown: + self.tmpValue = self.value + self.value = self.suggestionsWindow.activate() + self.allmarked = False + #self.marked_pos = -1 + self.suggestionsListActivated = True + ret = True + return ret + + def deactivateSuggestionList(self): + ret = False + if self.suggestionsWindow is not None: + self.suggestionsWindow.deactivate() + self.getSuggestions() + self.allmarked = True + self.suggestionsListActivated = False + ret = True + return ret + + def cancelSuggestionList(self): + self.value = self.tmpValue + return self.deactivateSuggestionList() + + def enableSuggestionSelection(self,value): + if self.suggestionsWindow is not None: + self.suggestionsWindow.enableSelection(value) + + +config.plugins.mytube = ConfigSubsection() +config.plugins.mytube.search = ConfigSubsection() + +config.plugins.mytube.search.searchTerm = ConfigTextWithGoogleSuggestions("", False, threaded = True) +config.plugins.mytube.search.orderBy = ConfigSelection( + [ + ("relevance", _("Relevance")), + ("viewCount", _("View Count")), + ("published", _("Published")), + ("rating", _("Rating")) + ], "relevance") +config.plugins.mytube.search.time = ConfigSelection( + [ + ("all_time", _("All Time")), + ("this_month", _("This Month")), + ("this_week", _("This Week")), + ("today", _("Today")) + ], "all_time") +config.plugins.mytube.search.racy = ConfigSelection( + [ + ("include", _("Yes")), + ("exclude", _("No")) + ], "include") +config.plugins.mytube.search.categories = ConfigSelection( + [ + (None, _("All")), + ("Film", _("Film & Animation")), + ("Autos", _("Autos & Vehicles")), + ("Music", _("Music")), + ("Animals", _("Pets & Animals")), + ("Sports", _("Sports")), + ("Travel", _("Travel & Events")), + ("Shortmov", _("Short Movies")), + ("Games", _("Gaming")), + ("Comedy", _("Comedy")), + ("People", _("People & Blogs")), + ("News", _("News & Politics")), + ("Entertainment", _("Entertainment")), + ("Education", _("Education")), + ("Howto", _("Howto & Style")), + ("Nonprofit", _("Nonprofits & Activism")), + ("Tech", _("Science & Technology")) + ], None) +config.plugins.mytube.search.lr = ConfigSelection( + [ + (None, _("All")), + ("au", _("Australia")), + ("br", _("Brazil")), + ("ca", _("Canada")), + ("cz", _("Czech Republic")), + ("fr", _("France")), + ("de", _("Germany")), + ("gb", _("Great Britain")), + ("au", _("Australia")), + ("nl", _("Holland")), + ("hk", _("Hong Kong")), + ("in", _("India")), + ("ie", _("Ireland")), + ("il", _("Israel")), + ("it", _("Italy")), + ("jp", _("Japan")), + ("mx", _("Mexico")), + ("nz", _("New Zealand")), + ("pl", _("Poland")), + ("ru", _("Russia")), + ("kr", _("South Korea")), + ("es", _("Spain")), + ("se", _("Sweden")), + ("tw", _("Taiwan")), + ("us", _("United States")) + ], None) +config.plugins.mytube.search.sortOrder = ConfigSelection( + [ + ("ascending", _("Ascending")), + ("descending", _("Descending")) + ], "ascending") + +config.plugins.mytube.general = ConfigSubsection() +config.plugins.mytube.general.showHelpOnOpen = ConfigYesNo(default = True) +config.plugins.mytube.general.loadFeedOnOpen = ConfigYesNo(default = True) +config.plugins.mytube.general.startFeed = ConfigSelection( + [ + ("hd", _("HD videos")), + ("most_viewed", _("Most viewed")), + ("top_rated", _("Top rated")), + ("recently_featured", _("Recently featured")), + ("most_discussed", _("Most discussed")), + ("top_favorites", _("Top favorites")), + ("most_linked", _("Most linked")), + ("most_responded", _("Most responded")), + ("most_recent", _("Most recent")) + ], "most_viewed") + +config.plugins.mytube.general.on_movie_stop = ConfigSelection(default = "ask", choices = [ + ("ask", _("Ask user")), ("quit", _("Return to movie list")), ("playnext", _("Play next video")), ("playagain", _("Play video again")) ]) + +config.plugins.mytube.general.on_exit = ConfigSelection(default = "ask", choices = [ + ("ask", _("Ask user")), ("quit", _("Return to movie list"))]) + + +default = resolveFilename(SCOPE_HDD) +tmp = config.movielist.videodirs.value +if default not in tmp: + tmp.append(default) +config.plugins.mytube.general.videodir = ConfigSelection(default = default, choices = tmp) +config.plugins.mytube.general.history = ConfigText(default="") +config.plugins.mytube.general.clearHistoryOnClose = ConfigYesNo(default = False) + +#config.plugins.mytube.general.useHTTPProxy = ConfigYesNo(default = False) +#config.plugins.mytube.general.ProxyIP = ConfigIP(default=[0,0,0,0]) +#config.plugins.mytube.general.ProxyPort = ConfigNumber(default=8080) + +class MyTubeSuggestionsListScreen(Screen): + skin = """ + + + + {"template": [ + MultiContentEntryText(pos = (0, 1), size = (340, 24), font=0, flags = RT_HALIGN_LEFT, text = 0), # index 0 is the name + MultiContentEntryText(pos = (350, 1), size = (180, 24), font=1, flags = RT_HALIGN_RIGHT, text = 1), # index 1 are the rtesults + ], + "fonts": [gFont("Regular", 22),gFont("Regular", 18)], + "itemHeight": 25 + } + + + """ + + def __init__(self, session, configTextWithGoogleSuggestion): + Screen.__init__(self, session) + self.activeState = False + self.list = [] + self.suggestlist = [] + self["suggestionslist"] = List(self.list) + self.configTextWithSuggestion = configTextWithGoogleSuggestion + + def update(self, suggestions): + if suggestions and len(suggestions[1]) > 0: + if not self.shown: + self.show() + if suggestions: + self.list = [] + self.suggestlist = [] + suggests = suggestions[1] + for suggestion in suggests: + name = suggestion[0] + results = suggestion[1].replace(" results", "") + numresults = results.replace(",", "") + self.suggestlist.append((name, numresults )) + if len(self.suggestlist): + self.suggestlist.sort(key=lambda x: int(x[1])) + self.suggestlist.reverse() + for entry in self.suggestlist: + self.list.append((entry[0], entry[1] + _(" Results") )) + self["suggestionslist"].setList(self.list) + self["suggestionslist"].setIndex(0) + else: + self.hide() + + def getlistlenght(self): + return len(self.list) + + def up(self): + print "up" + if self.list and len(self.list) > 0: + self["suggestionslist"].selectPrevious() + return self.getSelection() + + def down(self): + print "down" + if self.list and len(self.list) > 0: + self["suggestionslist"].selectNext() + return self.getSelection() + + def pageUp(self): + print "up" + if self.list and len(self.list) > 0: + self["suggestionslist"].selectPrevious() + return self.getSelection() + + def pageDown(self): + print "down" + if self.list and len(self.list) > 0: + self["suggestionslist"].selectNext() + return self.getSelection() + + def activate(self): + print "activate" + self.activeState = True + return self.getSelection() + + def deactivate(self): + print "deactivate" + self.activeState = False + return self.getSelection() + + def getSelection(self): + if self["suggestionslist"].getCurrent() is None: + return None + print self["suggestionslist"].getCurrent()[0] + return self["suggestionslist"].getCurrent()[0] + + def enableSelection(self,value): + self["suggestionslist"].selectionEnabled(value) + + +class MyTubeSettingsScreen(Screen, ConfigListScreen): + skin = """ + + + + + + + + + + + """ + + def __init__(self, session, plugin_path): + Screen.__init__(self, session) + self.skin_path = plugin_path + self.session = session + + self["shortcuts"] = ActionMap(["ShortcutActions", "WizardActions", "MediaPlayerActions"], + { + "ok": self.keyOK, + "back": self.keyCancel, + "red": self.keyCancel, + "green": self.keySave, + "up": self.keyUp, + "down": self.keyDown, + "left": self.keyLeft, + "right": self.keyRight, + }, -1) + + self["key_red"] = Button(_("Close")) + self["key_green"] = Button(_("Save")) + self["title"] = Label() + + self.searchContextEntries = [] + self.ProxyEntry = None + self.loadFeedEntry = None + self.VideoDirname = None + ConfigListScreen.__init__(self, self.searchContextEntries, session) + self.createSetup() + self.onLayoutFinish.append(self.layoutFinished) + self.onShown.append(self.setWindowTitle) + + def layoutFinished(self): + self["title"].setText(_("MyTubePlayer settings")) + + def setWindowTitle(self): + self.setTitle(_("MyTubePlayer settings")) + + def createSetup(self): + self.searchContextEntries = [] + self.searchContextEntries.append(getConfigListEntry(_("Display search results by:"), config.plugins.mytube.search.orderBy)) + self.searchContextEntries.append(getConfigListEntry(_("Search restricted content:"), config.plugins.mytube.search.racy)) + self.searchContextEntries.append(getConfigListEntry(_("Search category:"), config.plugins.mytube.search.categories)) + self.searchContextEntries.append(getConfigListEntry(_("Search region:"), config.plugins.mytube.search.lr)) + self.loadFeedEntry = getConfigListEntry(_("Load feed on startup:"), config.plugins.mytube.general.loadFeedOnOpen) + self.searchContextEntries.append(self.loadFeedEntry) + if config.plugins.mytube.general.loadFeedOnOpen.value: + self.searchContextEntries.append(getConfigListEntry(_("Start with following feed:"), config.plugins.mytube.general.startFeed)) + self.searchContextEntries.append(getConfigListEntry(_("Videoplayer stop/exit behavior:"), config.plugins.mytube.general.on_movie_stop)) + self.searchContextEntries.append(getConfigListEntry(_("Videobrowser exit behavior:"), config.plugins.mytube.general.on_exit)) + """self.ProxyEntry = getConfigListEntry(_("Use HTTP Proxy Server:"), config.plugins.mytube.general.useHTTPProxy) + self.searchContextEntries.append(self.ProxyEntry) + if config.plugins.mytube.general.useHTTPProxy.value: + self.searchContextEntries.append(getConfigListEntry(_("HTTP Proxy Server IP:"), config.plugins.mytube.general.ProxyIP)) + self.searchContextEntries.append(getConfigListEntry(_("HTTP Proxy Server Port:"), config.plugins.mytube.general.ProxyPort))""" + # disabled until i have time for some proper tests + self.VideoDirname = getConfigListEntry(_("Download location"), config.plugins.mytube.general.videodir) + if config.usage.setup_level.index >= 2: # expert+ + self.searchContextEntries.append(self.VideoDirname) + self.searchContextEntries.append(getConfigListEntry(_("Clear history on Exit:"), config.plugins.mytube.general.clearHistoryOnClose)) + + self["config"].list = self.searchContextEntries + self["config"].l.setList(self.searchContextEntries) + if not self.selectionChanged in self["config"].onSelectionChanged: + self["config"].onSelectionChanged.append(self.selectionChanged) + + def selectionChanged(self): + current = self["config"].getCurrent() + #print current + + def newConfig(self): + print "newConfig", self["config"].getCurrent() + if self["config"].getCurrent() == self.loadFeedEntry: + self.createSetup() + + def keyOK(self): + cur = self["config"].getCurrent() + if config.usage.setup_level.index >= 2 and cur == self.VideoDirname: + self.session.openWithCallback( + self.pathSelected, + MovieLocationBox, + _("Choose target folder"), + config.plugins.mytube.general.videodir.value, + minFree = 100 # We require at least 100MB free space + ) + else: + self.keySave() + + def pathSelected(self, res): + if res is not None: + if config.movielist.videodirs.value != config.plugins.mytube.general.videodir.choices: + config.plugins.mytube.general.videodir.setChoices(config.movielist.videodirs.value, default=res) + config.plugins.mytube.general.videodir.value = res + + def keyUp(self): + self["config"].instance.moveSelection(self["config"].instance.moveUp) + + def keyDown(self): + self["config"].instance.moveSelection(self["config"].instance.moveDown) + + def keyRight(self): + ConfigListScreen.keyRight(self) + self.newConfig() + + def keyLeft(self): + ConfigListScreen.keyLeft(self) + self.newConfig() + + def keyCancel(self): + print "cancel" + for x in self["config"].list: + x[1].cancel() + self.close() + + def keySave(self): + print "saving" + config.plugins.mytube.search.orderBy.save() + config.plugins.mytube.search.racy.save() + config.plugins.mytube.search.categories.save() + config.plugins.mytube.search.lr.save() + config.plugins.mytube.general.loadFeedOnOpen.save() + config.plugins.mytube.general.startFeed.save() + config.plugins.mytube.general.on_movie_stop.save() + config.plugins.mytube.general.on_exit.save() + config.plugins.mytube.general.videodir.save() + config.plugins.mytube.general.clearHistoryOnClose.save() + if config.plugins.mytube.general.clearHistoryOnClose.value: + config.plugins.mytube.general.history.value = "" + config.plugins.mytube.general.history.save() + #config.plugins.mytube.general.useHTTPProxy.save() + #config.plugins.mytube.general.ProxyIP.save() + #config.plugins.mytube.general.ProxyPort.save() + for x in self["config"].list: + x[1].save() + config.plugins.mytube.general.save() + config.plugins.mytube.search.save() + config.plugins.mytube.save() + """if config.plugins.mytube.general.useHTTPProxy.value is True: + proxy = {'http': 'http://'+str(config.plugins.mytube.general.ProxyIP.getText())+':'+str(config.plugins.mytube.general.ProxyPort.value)} + self.myopener = MyOpener(proxies=proxy) + urllib.urlopen = MyOpener(proxies=proxy).open + else: + self.myopener = MyOpener() + urllib.urlopen = MyOpener().open""" + self.close() + + +class MyTubeTasksScreen(Screen): + skin = """ + + + + + + {"template": [ + MultiContentEntryText(pos = (0, 1), size = (200, 24), font=1, flags = RT_HALIGN_LEFT, text = 1), # index 1 is the name + MultiContentEntryText(pos = (210, 1), size = (150, 24), font=1, flags = RT_HALIGN_RIGHT, text = 2), # index 2 is the state + MultiContentEntryProgress(pos = (370, 1), size = (100, 24), percent = -3), # index 3 should be progress + MultiContentEntryText(pos = (480, 1), size = (100, 24), font=1, flags = RT_HALIGN_RIGHT, text = 4), # index 4 is the percentage + ], + "fonts": [gFont("Regular", 22),gFont("Regular", 18)], + "itemHeight": 25 + } + + + + + + """ + + def __init__(self, session, plugin_path, tasklist): + Screen.__init__(self, session) + self.skin_path = plugin_path + self.session = session + self.tasklist = tasklist + self["tasklist"] = List(self.tasklist) + + self["shortcuts"] = ActionMap(["ShortcutActions", "WizardActions", "MediaPlayerActions"], + { + "ok": self.keyOK, + "back": self.keyCancel, + "red": self.keyCancel, + }, -1) + + self["key_red"] = Button(_("Close")) + self["title"] = Label() + + self.onLayoutFinish.append(self.layoutFinished) + self.onShown.append(self.setWindowTitle) + self.onClose.append(self.__onClose) + self.Timer = eTimer() + self.Timer.callback.append(self.TimerFire) + + def __onClose(self): + del self.Timer + + def layoutFinished(self): + self["title"].setText(_("MyTubePlayer active video downloads")) + self.Timer.startLongTimer(2) + #self.Timer.start(1000) + + def TimerFire(self): + self.Timer.stop() + self.rebuildTaskList() + + def rebuildTaskList(self): + self.tasklist = [] + for job in job_manager.getPendingJobs(): + self.tasklist.append((job,job.name,job.getStatustext(),int(100*job.progress/float(job.end)) ,str(100*job.progress/float(job.end)) + "%" )) + self['tasklist'].setList(self.tasklist) + self['tasklist'].updateList(self.tasklist) + self.Timer.startLongTimer(2) + + def setWindowTitle(self): + self.setTitle(_("MyTubePlayer active video downloads")) + + def keyOK(self): + current = self["tasklist"].getCurrent() + print current + if current: + job = current[0] + from Screens.TaskView import JobView + self.session.openWithCallback(self.JobViewCB, JobView, job) + + def JobViewCB(self, why): + print "WHY---",why + + def keyCancel(self): + self.close() + + def keySave(self): + self.close() + + +class MyTubeHistoryScreen(Screen): + skin = """ + + + + {"template": [ + MultiContentEntryText(pos = (0, 1), size = (340, 24), font=0, flags = RT_HALIGN_LEFT, text = 0), # index 0 is the name + ], + "fonts": [gFont("Regular", 22),gFont("Regular", 18)], + "itemHeight": 25 + } + + + """ + + def __init__(self, session): + Screen.__init__(self, session) + self.session = session + self.historylist = [] + print "self.historylist",self.historylist + self["historylist"] = List(self.historylist) + self.activeState = False + + def activate(self): + print "activate" + self.activeState = True + self.history = config.plugins.mytube.general.history.value.split(',') + if self.history[0] == '': + del self.history[0] + print "self.history",self.history + self.historylist = [] + for entry in self.history: + self.historylist.append(( str(entry),)) + self["historylist"].setList(self.historylist) + self["historylist"].updateList(self.historylist) + + def deactivate(self): + print "deactivate" + self.activeState = False + + def status(self): + print self.activeState + return self.activeState + + def getSelection(self): + if self["historylist"].getCurrent() is None: + return None + print self["historylist"].getCurrent()[0] + return self["historylist"].getCurrent()[0] + + def up(self): + print "up" + self["historylist"].selectPrevious() + return self.getSelection() + + def down(self): + print "down" + self["historylist"].selectNext() + return self.getSelection() + + def pageUp(self): + print "up" + self["historylist"].selectPrevious() + return self.getSelection() + + def pageDown(self): + print "down" + self["historylist"].selectNext() + return self.getSelection() + + Index: /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/MyTubeService.py =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/MyTubeService.py (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/MyTubeService.py (revision 8781) @@ -0,0 +1,357 @@ +# -*- coding: iso-8859-1 -*- +import gdata.youtube +import gdata.youtube.service +from gdata.service import BadAuthentication +from Tools.LoadPixmap import LoadPixmap +from Components.config import config, Config, ConfigSelection, ConfigText, getConfigListEntry, ConfigSubsection, ConfigYesNo, ConfigIP, ConfigNumber +from Components.ConfigList import ConfigListScreen +from Components.config import KEY_DELETE, KEY_BACKSPACE, KEY_LEFT, KEY_RIGHT, KEY_HOME, KEY_END, KEY_TOGGLEOW, KEY_ASCII, KEY_TIMEOUT + +from twisted.web import client +from twisted.internet import reactor +from urllib2 import Request, URLError, HTTPError, urlopen as urlopen2 +from socket import gaierror,error +import re, os, sys, socket +from urllib import quote, unquote_plus, unquote +import cookielib +from httplib import HTTPConnection,CannotSendRequest,BadStatusLine,HTTPException +HTTPConnection.debuglevel = 1 +from urlparse import parse_qs + +def validate_cert(cert, key): + buf = decrypt_block(cert[8:], key) + if buf is None: + return None + return buf[36:107] + cert[139:196] + +def get_rnd(): + try: + rnd = os.urandom(8) + return rnd + except: + return None + +std_headers = { + 'User-Agent': 'Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.6) Gecko/20100627 Firefox/3.6.6', + 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7', + 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', + 'Accept-Language': 'en-us,en;q=0.5', +} + +#config.plugins.mytube = ConfigSubsection() +#config.plugins.mytube.general = ConfigSubsection() +#config.plugins.mytube.general.useHTTPProxy = ConfigYesNo(default = False) +#config.plugins.mytube.general.ProxyIP = ConfigIP(default=[0,0,0,0]) +#config.plugins.mytube.general.ProxyPort = ConfigNumber(default=8080) +#class MyOpener(FancyURLopener): +# version = 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12' + + +class GoogleSuggestions(): + def __init__(self, callback, ds = None, json = None, hl = None): + self.callback = callback + self.conn = HTTPConnection("google.com") + #GET /complete/search?output=toolbar&ds=yt&hl=en&jsonp=self.gotSuggestions&q=s + self.prepQuerry = "/complete/search?output=toolbar&" + if ds is not None: + self.prepQuerry = self.prepQuerry + "ds=" + ds + "&" + if json is not None: + self.prepQuerry = self.prepQuerry + "json=" + json + "&" + if hl is not None: + self.prepQuerry = self.prepQuerry + "hl=" + hl + "&" + self.prepQuerry = self.prepQuerry + "jsonp=self.gotSuggestions&q=" + + def gotSuggestions(self, suggestslist): + self.callback(suggestslist) + + def getSuggestions(self, querryString): + if querryString is not "": + querry = self.prepQuerry + quote(querryString) + try: + self.conn.request("GET", querry) + except (CannotSendRequest, gaierror, error): + print "[MyTube] Can not send request for suggestions" + self.callback(None) + else: + try: + response = self.conn.getresponse() + except BadStatusLine: + print "[MyTube] Can not get a response from google" + self.callback(None) + else: + if response.status == 200: + data = response.read() + self.gotSuggestions(data) + else: + self.callback(None) + self.conn.close() + else: + self.callback(None) + + +class MyTubeFeedEntry(): + def __init__(self, feed, entry, favoritesFeed = False): + self.feed = feed + self.entry = entry + self.favoritesFeed = favoritesFeed + self.thumbnail = {} + """self.myopener = MyOpener() + urllib.urlopen = MyOpener().open + if config.plugins.mytube.general.useHTTPProxy.value is True: + proxy = {'http': 'http://'+str(config.plugins.mytube.general.ProxyIP.getText())+':'+str(config.plugins.mytube.general.ProxyPort.value)} + self.myopener = MyOpener(proxies=proxy) + urllib.urlopen = MyOpener(proxies=proxy).open + else: + self.myopener = MyOpener() + urllib.urlopen = MyOpener().open""" + + def isPlaylistEntry(self): + return False + + def getTubeId(self): + #print "[MyTubeFeedEntry] getTubeId" + ret = None + if self.entry.media.player: + split = self.entry.media.player.url.split("=") + ret = split.pop() + if ret.startswith('youtube_gdata'): + tmpval=split.pop() + if tmpval.endswith("&feature"): + tmp = tmpval.split("&") + ret = tmp.pop(0) + return ret + + def getTitle(self): + #print "[MyTubeFeedEntry] getTitle",self.entry.media.title.text + return self.entry.media.title.text + + def getDescription(self): + #print "[MyTubeFeedEntry] getDescription" + if self.entry.media is not None and self.entry.media.description is not None: + return self.entry.media.description.text + return "not vailable" + + def getThumbnailUrl(self, index = 0): + #print "[MyTubeFeedEntry] getThumbnailUrl" + if index < len(self.entry.media.thumbnail): + return self.entry.media.thumbnail[index].url + return None + + def getPublishedDate(self): + if self.entry.published is not None: + return self.entry.published.text + return "unknown" + + def getViews(self): + if self.entry.statistics is not None: + return self.entry.statistics.view_count + return "not available" + + def getDuration(self): + if self.entry.media is not None and self.entry.media.duration is not None: + return self.entry.media.duration.seconds + else: + return 0 + + def getRatingAverage(self): + if self.entry.rating is not None: + return self.entry.rating.average + return 0 + + + def getNumRaters(self): + if self.entry.rating is not None: + return self.entry.rating.num_raters + return "" + + def getAuthor(self): + authors = [] + for author in self.entry.author: + authors.append(author.name.text) + author = ", ".join(authors) + return author + + def PrintEntryDetails(self): + EntryDetails = { 'Title': None, 'TubeID': None, 'Published': None, 'Published': None, 'Description': None, 'Category': None, 'Tags': None, 'Duration': None, 'Views': None, 'Rating': None, 'Thumbnails': None} + EntryDetails['Title'] = self.entry.media.title.text + EntryDetails['TubeID'] = self.getTubeId() + EntryDetails['Description'] = self.getDescription() + EntryDetails['Category'] = self.entry.media.category[0].text + EntryDetails['Tags'] = self.entry.media.keywords.text + EntryDetails['Published'] = self.getPublishedDate() + EntryDetails['Views'] = self.getViews() + EntryDetails['Duration'] = self.getDuration() + EntryDetails['Rating'] = self.getNumRaters() + EntryDetails['RatingAverage'] = self.getRatingAverage() + EntryDetails['Author'] = self.getAuthor() + # show thumbnails + list = [] + for thumbnail in self.entry.media.thumbnail: + print 'Thumbnail url: %s' % thumbnail.url + list.append(str(thumbnail.url)) + EntryDetails['Thumbnails'] = list + #print EntryDetails + return EntryDetails + + def getVideoUrl(self): + VIDEO_FMT_PRIORITY_MAP = { + '38' : 1, #MP4 Original (HD) + '37' : 2, #MP4 1080p (HD) + '22' : 3, #MP4 720p (HD) + '18' : 4, #MP4 360p + '35' : 5, #FLV 480p + '34' : 6, #FLV 360p + } + video_url = None + video_id = str(self.getTubeId()) + + # Getting video webpage + #URLs for YouTube video pages will change from the format http://www.youtube.com/watch?v=ylLzyHk54Z0 to http://www.youtube.com/watch#!v=ylLzyHk54Z0. + watch_url = 'http://www.youtube.com/watch?v=%s&gl=US&hl=en' % video_id + watchrequest = Request(watch_url, None, std_headers) + try: + print "[MyTube] trying to find out if a HD Stream is available",watch_url + watchvideopage = urlopen2(watchrequest).read() + except (URLError, HTTPException, socket.error), err: + print "[MyTube] Error: Unable to retrieve watchpage - Error code: ", str(err) + return video_url + + # Get video info + for el in ['&el=embedded', '&el=detailpage', '&el=vevo', '']: + info_url = ('http://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en' % (video_id, el)) + request = Request(info_url, None, std_headers) + try: + infopage = urlopen2(request).read() + videoinfo = parse_qs(infopage) + if 'fmt_url_map' in videoinfo: + break + except (URLError, HTTPException, socket.error), err: + print "[MyTube] Error: unable to download video infopage",str(err) + return video_url + + if 'fmt_url_map' not in videoinfo: + # Attempt to see if YouTube has issued an error message + if 'reason' not in videoinfo: + print '[MyTube] Error: unable to extract "fmt_url_map" parameter for unknown reason' + else: + reason = unquote_plus(videoinfo['reason'][0]) + print '[MyTube] Error: YouTube said: %s' % reason.decode('utf-8') + return video_url + + video_fmt_map = {} + fmt_infomap = {} + tmp_fmtUrlDATA = videoinfo['fmt_url_map'][0].split(',') + for fmtstring in tmp_fmtUrlDATA: + (fmtid,fmturl) = fmtstring.split('|') + if VIDEO_FMT_PRIORITY_MAP.has_key(fmtid): + video_fmt_map[VIDEO_FMT_PRIORITY_MAP[fmtid]] = { 'fmtid': fmtid, 'fmturl': unquote_plus(fmturl) } + fmt_infomap[int(fmtid)] = unquote_plus(fmturl) + print "[MyTube] got",sorted(fmt_infomap.iterkeys()) + if video_fmt_map and len(video_fmt_map): + print "[MyTube] found best available video format:",video_fmt_map[sorted(video_fmt_map.iterkeys())[0]]['fmtid'] + video_url = video_fmt_map[sorted(video_fmt_map.iterkeys())[0]]['fmturl'] + print "[MyTube] found best available video url:",video_url + + return video_url + + def getRelatedVideos(self): + print "[MyTubeFeedEntry] getResponseVideos()" + for link in self.entry.link: + #print "Related link: ", link.rel.endswith + if link.rel.endswith("video.related"): + print "Found Related: ", link.href + return link.href + + def getResponseVideos(self): + print "[MyTubeFeedEntry] getResponseVideos()" + for link in self.entry.link: + #print "Responses link: ", link.rel.endswith + if link.rel.endswith("video.responses"): + print "Found Responses: ", link.href + return link.href + +class MyTubePlayerService(): +# Do not change the client_id and developer_key in the login-section! +# ClientId: ytapi-dream-MyTubePlayer-i0kqrebg-0 +# DeveloperKey: AI39si4AjyvU8GoJGncYzmqMCwelUnqjEMWTFCcUtK-VUzvWygvwPO-sadNwW5tNj9DDCHju3nnJEPvFy4WZZ6hzFYCx8rJ6Mw + def __init__(self): + print "[MyTube] MyTubePlayerService - init" + self.feedentries = [] + self.feed = None + + def startService(self): + print "[MyTube] MyTubePlayerService - startService" + self.yt_service = gdata.youtube.service.YouTubeService() + self.yt_service.developer_key = 'AI39si4AjyvU8GoJGncYzmqMCwelUnqjEMWTFCcUtK-VUzvWygvwPO-sadNwW5tNj9DDCHju3nnJEPvFy4WZZ6hzFYCx8rJ6Mw' + self.yt_service.client_id = 'ytapi-dream-MyTubePlayer-i0kqrebg-0' + self.loggedIn = False + #os.environ['http_proxy'] = 'http://169.229.50.12:3128' + #proxy = os.environ.get('http_proxy') + #print "FOUND ENV PROXY-->",proxy + #for a in os.environ.keys(): + # print a + + def stopService(self): + print "[MyTube] MyTubePlayerService - stopService" + del self.ytService + self.loggedIn = False + + def isLoggedIn(self): + return self.loggedIn + + def getFeed(self, url): + print "[MyTube] MyTubePlayerService - getFeed:",url + self.feedentries = [] + self.feed = self.yt_service.GetYouTubeVideoFeed(url) + for entry in self.feed.entry: + MyFeedEntry = MyTubeFeedEntry(self, entry) + self.feedentries.append(MyFeedEntry) + return self.feed + + def search(self, searchTerms, startIndex = 1, maxResults = 25, + orderby = "relevance", racy = "include", + author = "", lr = "", categories = "", sortOrder = "ascending"): + print "[MyTube] MyTubePlayerService - search()" + self.feedentries = [] + query = gdata.youtube.service.YouTubeVideoQuery() + query.vq = searchTerms + query.orderby = orderby + query.racy = racy + query.sortorder = sortOrder + if lr is not None: + query.lr = lr + if categories[0] is not None: + query.categories = categories + query.start_index = startIndex + query.max_results = maxResults + try: + feed = self.yt_service.YouTubeQuery(query) + except gaierror: + feed = None + if feed is not None: + self.feed = feed + for entry in self.feed.entry: + MyFeedEntry = MyTubeFeedEntry(self, entry) + self.feedentries.append(MyFeedEntry) + return self.feed + + def getTitle(self): + return self.feed.title.text + + def getEntries(self): + return self.feedentries + + def itemCount(self): + return self.feed.items_per_page.text + + def getTotalResults(self): + return self.feed.total_results.text + + def getNextFeedEntriesURL(self): + for link in self.feed.link: + if link.rel == "next": + return link.href + return None + + +myTubeService = MyTubePlayerService() Index: /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/__init__.py =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/__init__.py (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/__init__.py (revision 8781) @@ -0,0 +1,22 @@ +# -*- coding: ISO-8859-1 -*- +from Components.Language import language +from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_LANGUAGE +import os,gettext +PluginLanguageDomain = "MyTube" +PluginLanguagePath = "Extensions/MyTube/po" + +def localeInit(): + lang = language.getLanguage()[:2] # getLanguage returns e.g. "fi_FI" for "language_country" + os.environ["LANGUAGE"] = lang # Enigma doesn't set this (or LC_ALL, LC_MESSAGES, LANG). gettext needs it! + print "[MyTube] set language to ", lang + gettext.bindtextdomain(PluginLanguageDomain, resolveFilename(SCOPE_PLUGINS, PluginLanguagePath)) + +def _(txt): + t = gettext.dgettext(PluginLanguageDomain, txt) + if t == txt: + #print "[MyTube] fallback to default translation for", txt + t = gettext.gettext(txt) + return t + +localeInit() +language.addCallback(localeInit) Index: /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/maintainer.info =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/maintainer.info (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/maintainer.info (revision 8781) @@ -0,0 +1,2 @@ +acid-burn@opendreambox.org +MyTube Index: /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/plugin.py =================================================================== --- /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/plugin.py (revision 8781) +++ /ipk/source.sh4/swapplayers_mytube_1_0/var/swap/extensions/MyTube/plugin.py (revision 8781) @@ -0,0 +1,1741 @@ +from __init__ import _ +from Plugins.Plugin import PluginDescriptor +from MyTubeService import GoogleSuggestions +from MyTubeSearch import ConfigTextWithGoogleSuggestions +from Tools.BoundFunction import boundFunction +from Screens.MessageBox import MessageBox +from Screens.Screen import Screen +from Screens.ChoiceBox import ChoiceBox +from Screens.InfoBar import MoviePlayer +from Screens.VirtualKeyBoard import VirtualKeyBoard +from Components.ActionMap import ActionMap, NumberActionMap +from Components.Label import Label +from Components.ScrollLabel import ScrollLabel +from Components.ProgressBar import ProgressBar +from Components.Pixmap import Pixmap +from Components.Button import Button +from Components.Sources.List import List +from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest +from Components.AVSwitch import AVSwitch +from Components.ActionMap import HelpableActionMap +from Components.config import config, Config, ConfigSelection, ConfigSubsection, ConfigText, getConfigListEntry, ConfigYesNo, ConfigIP, ConfigNumber,ConfigLocations +from Components.config import KEY_DELETE, KEY_BACKSPACE, KEY_LEFT, KEY_RIGHT, KEY_HOME, KEY_END, KEY_TOGGLEOW, KEY_ASCII, KEY_TIMEOUT +from Components.ConfigList import ConfigListScreen +from Components.ServiceEventTracker import ServiceEventTracker, InfoBarBase +from Components.Console import Console +from Components.Sources.Source import Source +from Components.Task import Task, Job, job_manager + +from threading import Thread +from threading import Condition + +from Tools.Directories import pathExists, fileExists, resolveFilename, SCOPE_PLUGINS, SCOPE_SKIN_IMAGE, SCOPE_HDD +from Tools.LoadPixmap import LoadPixmap +from Tools.Downloader import HTTPProgressDownloader, downloadWithProgress +from enigma import eTimer, quitMainloop,eListbox,ePoint, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_VALIGN_CENTER, eListboxPythonMultiContent, eListbox, gFont, getDesktop, ePicLoad, eServiceCenter, iServiceInformation, eServiceReference,iSeekableService,iServiceInformation, iPlayableService, iPlayableServicePtr +from os import path as os_path, system as os_system, unlink, stat, mkdir, popen, makedirs, listdir, access, rename, remove, W_OK, R_OK, F_OK +from twisted.web import client +from twisted.internet import reactor +from time import time + +from Screens.InfoBarGenerics import InfoBarShowHide, InfoBarSeek, InfoBarNotifications, InfoBarServiceNotifications + +config.plugins.mytube = ConfigSubsection() +config.plugins.mytube.search = ConfigSubsection() + +config.plugins.mytube.search.searchTerm = ConfigTextWithGoogleSuggestions("", False, threaded = True) +config.plugins.mytube.search.orderBy = ConfigSelection( + [ + ("relevance", _("Relevance")), + ("viewCount", _("View Count")), + ("published", _("Published")), + ("rating", _("Rating")) + ], "relevance") +config.plugins.mytube.search.time = ConfigSelection( + [ + ("all_time", _("All Time")), + ("this_month", _("This Month")), + ("this_week", _("This Week")), + ("today", _("Today")) + ], "all_time") +config.plugins.mytube.search.racy = ConfigSelection( + [ + ("include", _("Yes")), + ("exclude", _("No")) + ], "include") +config.plugins.mytube.search.categories = ConfigSelection( + [ + (None, _("All")), + ("Film", _("Film & Animation")), + ("Autos", _("Autos & Vehicles")), + ("Music", _("Music")), + ("Animals", _("Pets & Animals")), + ("Sports", _("Sports")), + ("Travel", _("Travel & Events")), + ("Shortmov", _("Short Movies")), + ("Games", _("Gaming")), + ("Comedy", _("Comedy")), + ("People", _("People & Blogs")), + ("News", _("News & Politics")), + ("Entertainment", _("Entertainment")), + ("Education", _("Education")), + ("Howto", _("Howto & Style")), + ("Nonprofit", _("Nonprofits & Activism")), + ("Tech", _("Science & Technology")) + ], None) +config.plugins.mytube.search.lr = ConfigSelection( + [ + (None, _("All")), + ("au", _("Australia")), + ("br", _("Brazil")), + ("ca", _("Canada")), + ("cz", _("Czech Republic")), + ("fr", _("France")), + ("de", _("Germany")), + ("gb", _("Great Britain")), + ("au", _("Australia")), + ("nl", _("Holland")), + ("hk", _("Hong Kong")), + ("in", _("India")), + ("ie", _("Ireland")), + ("il", _("Israel")), + ("it", _("Italy")), + ("jp", _("Japan")), + ("mx", _("Mexico")), + ("nz", _("New Zealand")), + ("pl", _("Poland")), + ("ru", _("Russia")), + ("kr", _("South Korea")), + ("es", _("Spain")), + ("se", _("Sweden")), + ("tw", _("Taiwan")), + ("us", _("United States")) + ], None) +config.plugins.mytube.search.sortOrder = ConfigSelection( + [ + ("ascending", _("Ascending")), + ("descending", _("Descending")) + ], "ascending") + +config.plugins.mytube.general = ConfigSubsection() +config.plugins.mytube.general.showHelpOnOpen = ConfigYesNo(default = True) +config.plugins.mytube.general.loadFeedOnOpen = ConfigYesNo(default = True) +config.plugins.mytube.general.startFeed = ConfigSelection( + [ + ("hd", _("HD videos")), + ("most_viewed", _("Most viewed")), + ("top_rated", _("Top rated")), + ("recently_featured", _("Recently featured")), + ("most_discussed", _("Most discussed")), + ("top_favorites", _("Top favorites")), + ("most_linked", _("Most linked")), + ("most_responded", _("Most responded")), + ("most_recent", _("Most recent")) + ], "most_viewed") +config.plugins.mytube.general.on_movie_stop = ConfigSelection(default = "ask", choices = [ + ("ask", _("Ask user")), ("quit", _("Return to movie list")), ("playnext", _("Play next video")), ("playagain", _("Play video again")) ]) + +config.plugins.mytube.general.on_exit = ConfigSelection(default = "ask", choices = [ + ("ask", _("Ask user")), ("quit", _("Return to movie list"))]) + +default = resolveFilename(SCOPE_HDD) +tmp = config.movielist.videodirs.value +if default not in tmp: + tmp.append(default) +config.plugins.mytube.general.videodir = ConfigSelection(default = default, choices = tmp) +config.plugins.mytube.general.history = ConfigText(default="") +config.plugins.mytube.general.clearHistoryOnClose = ConfigYesNo(default = False) +#config.plugins.mytube.general.useHTTPProxy = ConfigYesNo(default = False) +#config.plugins.mytube.general.ProxyIP = ConfigIP(default=[0,0,0,0]) +#config.plugins.mytube.general.ProxyPort = ConfigNumber(default=8080) + +class downloadJob(Job): + def __init__(self, url, file, title): + Job.__init__(self, title) + downloadTask(self, url, file) + +class downloadTask(Task): + def __init__(self, job, url, file): + Task.__init__(self, job, ("download task")) + self.end = 100 + self.url = url + self.local = file + + def prepare(self): + self.error = None + + def run(self, callback): + self.callback = callback + self.download = downloadWithProgress(self.url,self.local) + self.download.addProgress(self.http_progress) + self.download.start().addCallback(self.http_finished).addErrback(self.http_failed) + + def http_progress(self, recvbytes, totalbytes): + #print "[http_progress] recvbytes=%d, totalbytes=%d" % (recvbytes, totalbytes) + self.progress = int(self.end*recvbytes/float(totalbytes)) + + def http_finished(self, string=""): + print "[http_finished]" + str(string) + Task.processFinished(self, 0) + + def http_failed(self, failure_instance=None, error_message=""): + if error_message == "" and failure_instance is not None: + error_message = failure_instance.getErrorMessage() + print "[http_failed] " + error_message + Task.processFinished(self, 1) + + + +from MyTubeService import myTubeService +from MyTubeSearch import MyTubeSettingsScreen,MyTubeTasksScreen,MyTubeHistoryScreen + + +class MyTubePlayerMainScreen(Screen, ConfigListScreen): + BASE_STD_FEEDURL = "http://gdata.youtube.com/feeds/api/standardfeeds/" + #(entry, Title, Description, TubeID, thumbnail, PublishedDate,Views,duration,ratings ) + skin = """ + + + + + + {"templates": + {"default": (77,[ + MultiContentEntryPixmapAlphaTest(pos = (0, 0), size = (100, 75), png = 4), # index 4 is the thumbnail + MultiContentEntryText(pos = (100, 1), size = (500, 22), font=0, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 1), # index 1 is the Title + MultiContentEntryText(pos = (100, 24), size = (300, 18), font=1, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 5), # index 5 is the Published Date + MultiContentEntryText(pos = (100, 43), size = (300, 18), font=1, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 6), # index 6 is the Views Count + MultiContentEntryText(pos = (400, 24), size = (200, 18), font=1, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 7), # index 7 is the duration + MultiContentEntryText(pos = (400, 43), size = (200, 18), font=1, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 8), # index 8 is the ratingcount + ]), + "state": (77,[ + MultiContentEntryText(pos = (10, 1), size = (560, 28), font=2, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 0), # index 0 is the name + MultiContentEntryText(pos = (10, 22), size = (560, 46), font=3, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 1), # index 2 is the description + ]) + }, + "fonts": [gFont("Regular", 22),gFont("Regular", 18),gFont("Regular", 26),gFont("Regular", 20)], + "itemHeight": 77 + } + + + + + + + + + + + + + + + # fake entry for dynamic thumbnail resizing, currently there is no other way doing this. + + """ + + def __init__(self, session): + Screen.__init__(self, session) + self.session = session + self.skin_path = plugin_path + self.FeedURL = None + self.ytfeed = None + self.currentFeedName = None + self.videolist = [] + self.thumbnails = [] + self.video_playlist = [] + self.statuslist = [] + self.mytubeentries = None + self.index = 0 + self.maxentries = 0 + self.picloads = {} + self.oldfeedentrycount = 0 + self.appendEntries = False + self.lastservice = session.nav.getCurrentlyPlayingServiceReference() + self.propagateUpDownNormally = True + self.FirstRun = True + self.HistoryWindow = None + self.History = None + self.searchtext = _("Welcome to the MyTube Youtube Player.\n\nWhile entering your search term(s) you will get suggestions displayed matching your search term.\n\nTo select a suggestion press DOWN on your remote, select the desired result and press OK on your remote to start the search.\n\nPress exit to get back to the input field.") + self.feedtext = _("Welcome to the MyTube Youtube Player.\n\nUse the Bouqet+ button to navigate to the search field and the Bouqet- to navigate to the video entries.\n\nTo play a movie just press OK on your remote control.\n\nPress info to see the movie description.\n\nPress the Menu button for additional options.\n\nThe Help button shows this help again.") + self.currList = "configlist" + self.oldlist = None + self.CleanupConsole = None + self["feedlist"] = List(self.videolist) + self["thumbnail"] = Pixmap() + self["thumbnail"].hide() + self["HelpWindow"] = Pixmap() + self["HelpWindow"].hide() + self["key_red"] = Button(_("Close")) + self["key_green"] = Button(_("Std. Feeds")) + self["key_yellow"] = Button(_("History")) + self["ButtonBlue"] = Pixmap() + self["VKeyIcon"] = Pixmap() + self["ButtonBlue"].hide() + self["VKeyIcon"].hide() + + self["searchactions"] = ActionMap(["ShortcutActions", "WizardActions", "HelpActions", "MediaPlayerActions"], + { + "ok": self.keyOK, + "back": self.leavePlayer, + "red": self.leavePlayer, + "blue": self.openKeyboard, + "yellow": self.handleHistory, + "up": self.keyUp, + "down": self.handleSuggestions, + "left": self.keyLeft, + "right": self.keyRight, + "prevBouquet": self.switchToFeedList, + "nextBouquet": self.switchToConfigList, + "displayHelp": self.handleHelpWindow, + "menu" : self.handleMenu, + }, -2) + + self["suggestionactions"] = ActionMap(["ShortcutActions", "WizardActions", "MediaPlayerActions", "HelpActions"], + { + "ok": self.keyOK, + "back": self.switchToConfigList, + "red": self.switchToConfigList, + "nextBouquet": self.switchToConfigList, + "prevBouquet": self.switchToFeedList, + "up": self.keyUp, + "down": self.keyDown, + "left": self.keyLeft, + "right": self.keyRight, + }, -2) + + + self["videoactions"] = ActionMap(["ShortcutActions", "WizardActions", "MediaPlayerActions", "MovieSelectionActions", "HelpActions"], + { + "ok": self.keyOK, + "back": self.leavePlayer, + "red": self.leavePlayer, + "yellow": self.handleHistory, + "up": self.keyUp, + "down": self.keyDown, + "nextBouquet": self.switchToConfigList, + "green": self.keyStdFeed, + "showEventInfo": self.showVideoInfo, + "displayHelp": self.handleHelpWindow, + "menu" : self.handleMenu, + }, -2) + + self["statusactions"] = ActionMap(["ShortcutActions", "WizardActions", "HelpActions", "MediaPlayerActions"], + { + "back": self.leavePlayer, + "red": self.leavePlayer, + "nextBouquet": self.switchToConfigList, + "green": self.keyStdFeed, + "yellow": self.handleHistory, + }, -2) + + self["historyactions"] = ActionMap(["ShortcutActions", "WizardActions", "MediaPlayerActions", "MovieSelectionActions", "HelpActions"], + { + "ok": self.keyOK, + "back": self.closeHistory, + "red": self.closeHistory, + "yellow": self.handleHistory, + "up": self.keyUp, + "down": self.keyDown, + "left": self.keyLeft, + "right": self.keyRight, + }, -2) + + self["videoactions"].setEnabled(False) + self["statusactions"].setEnabled(False) + self["historyactions"].setEnabled(False) + self.timer = eTimer() + self.timer.callback.append(self.picloadTimeout) + self.SearchConfigEntry = None + self.searchContextEntries = [] + config.plugins.mytube.search.searchTerm.value = "" + ConfigListScreen.__init__(self, self.searchContextEntries, session) + self.createSetup() + self.onLayoutFinish.append(self.layoutFinished) + self.onShown.append(self.setWindowTitle) + self.onClose.append(self.__onClose) + self.Timer = eTimer() + self.Timer.callback.append(self.TimerFire) + + def __onClose(self): + del self.Timer + del self.timer + self.session.nav.playService(self.lastservice) + + def layoutFinished(self): + self.currList = "status" + #self["key_green"].hide() + current = self["config"].getCurrent() + if current[1].help_window.instance is not None: + current[1].help_window.instance.hide() + self.statuslist.append(( _("Fetching feed entries"), _("Trying to download the Youtube feed entries. Please wait..." ) )) + self["feedlist"].style = "state" + self['feedlist'].setList(self.statuslist) + self.Timer.start(200) + + def TimerFire(self): + self.Timer.stop() + if config.plugins.mytube.general.loadFeedOnOpen.value: + self.setState('getFeed') + else: + self.setState('byPass') + + def setWindowTitle(self): + self.setTitle(_("MyTubePlayer")) + + def createSetup(self): + self.searchContextEntries = [] + self.SearchConfigEntry = getConfigListEntry(_("Search Term(s)"), config.plugins.mytube.search.searchTerm) + self.searchContextEntries.append(self.SearchConfigEntry) + self["config"].list = self.searchContextEntries + self["config"].l.setList(self.searchContextEntries) + + def setState(self,status = None): + if status: + if self.FirstRun == True: + self.appendEntries = False + myTubeService.startService() + self.currList = "status" + self.statuslist = [] + self["videoactions"].setEnabled(False) + self["searchactions"].setEnabled(False) + #self["key_green"].hide() + self["config_actions"].setEnabled(False) + self["historyactions"].setEnabled(False) + self["statusactions"].setEnabled(True) + self["ButtonBlue"].hide() + self["VKeyIcon"].hide() + if self.HistoryWindow is not None: + self.HistoryWindow.deactivate() + self.HistoryWindow.instance.hide() + if status == 'getFeed': + self.hideSuggestions() + self.statuslist.append(( _("Fetching feed entries"), _("Trying to download the Youtube feed entries. Please wait..." ) )) + self["feedlist"].style = "state" + self['feedlist'].setList(self.statuslist) + elif status == 'getSearchFeed': + self.hideSuggestions() + self.statuslist.append(( _("Fetching search entries"), _("Trying to download the Youtube search results. Please wait..." ) )) + self["feedlist"].style = "state" + self['feedlist'].setList(self.statuslist) + elif status == 'Error': + self.hideSuggestions() + self.statuslist.append(( _("An error occured."), _("There was an error getting the feed entries. Please try again." ) )) + self["feedlist"].style = "state" + self['feedlist'].setList(self.statuslist) + elif status == 'noVideos': + self["key_green"].show() + self.hideSuggestions() + self.statuslist.append(( _("No videos to display"), _("Please select a standard feed or try searching for videos." ) )) + self["feedlist"].style = "state" + self['feedlist'].setList(self.statuslist) + elif status == 'byPass': + self.statuslist.append(( _("Not fetching feed entries"), _("Please enter your search term." ) )) + self["feedlist"].style = "state" + self['feedlist'].setList(self.statuslist) + self.switchToConfigList() + if self.FirstRun == True: + if config.plugins.mytube.general.loadFeedOnOpen.value: + if config.plugins.mytube.general.startFeed.value == 'hd': + self.FeedURL = "http://gdata.youtube.com/feeds/api/videos/-/HD" + else: + self.FeedURL = self.BASE_STD_FEEDURL + str(config.plugins.mytube.general.startFeed.value) + self.getFeed(self.FeedURL, str(config.plugins.mytube.general.startFeed.value)) + + + def handleHelpWindow(self): + print "[handleHelpWindow]" + if self.currList == "configlist": + self.hideSuggestions() + self.session.openWithCallback(self.ScreenClosed, MyTubeVideoHelpScreen, self.skin_path, wantedinfo = self.searchtext, wantedtitle = _("MyTubePlayer Help") ) + elif self.currList == "feedlist": + self.session.openWithCallback(self.ScreenClosed, MyTubeVideoHelpScreen, self.skin_path, wantedinfo = self.feedtext, wantedtitle = _("MyTubePlayer Help") ) + + def handleFirstHelpWindow(self): + print "[handleFirstHelpWindow]" + if config.plugins.mytube.general.showHelpOnOpen.value is True: + if self.currList == "configlist": + self.hideSuggestions() + self.session.openWithCallback(self.firstRunHelpClosed, MyTubeVideoHelpScreen, self.skin_path,wantedinfo = self.feedtext, wantedtitle = _("MyTubePlayer Help") ) + else: + self.FirstRun = False + + def firstRunHelpClosed(self): + if self.FirstRun == True: + self.FirstRun = False + self.switchToConfigList() + + def handleMenu(self): + print "currlist im HandleMenu:",self.currList + if self.currList == "configlist": + menulist = ( + (_("MyTube Settings"), "settings"), + ) + self.hideSuggestions() + self.session.openWithCallback(self.openMenu, ChoiceBox, title=_("Select your choice."), list = menulist) + + elif self.currList == "feedlist": + menulist = [(_("MyTube Settings"), "settings")] + menulist.extend(( + (_("View related videos"), "related"), + (_("View response videos"), "response") + )) + if config.usage.setup_level.index >= 2: # expert+ + menulist.extend(( + (_("Download Video"), "download"), + (_("View active downloads"), "downview") + )) + + self.hideSuggestions() + self.session.openWithCallback(self.openMenu, ChoiceBox, title=_("Select your choice."), list = menulist) + + def openMenu(self, answer): + answer = answer and answer[1] + print "openMenu - ANSWER",answer + if answer == "settings": + print "settings selected" + self.session.openWithCallback(self.ScreenClosed,MyTubeSettingsScreen, self.skin_path ) + elif answer == "related": + current = self["feedlist"].getCurrent()[0] + self.setState('getFeed') + self.getRelatedVideos(current) + elif answer == "response": + current = self["feedlist"].getCurrent()[0] + self.setState('getFeed') + self.getResponseVideos(current) + elif answer == "download": + if self.currList == "feedlist": + current = self[self.currList].getCurrent() + if current: + myentry = current[0] + if myentry: + myurl = myentry.getVideoUrl() + filename = str(config.plugins.mytube.general.videodir.value)+ str(myentry.getTitle()) + '.mp4' + job_manager.AddJob(downloadJob(myurl,filename, str(myentry.getTitle())[:30])) + elif answer == "downview": + self.tasklist = [] + for job in job_manager.getPendingJobs(): + self.tasklist.append((job,job.name,job.getStatustext(),int(100*job.progress/float(job.end)) ,str(100*job.progress/float(job.end)) + "%" )) + self.session.open(MyTubeTasksScreen, self.skin_path , self.tasklist) + elif answer == None: + print "No menuentry selected, we should just switch back to old state." + self.ScreenClosed() + + def openKeyboard(self): + self.hideSuggestions() + self.session.openWithCallback(self.SearchEntryCallback, VirtualKeyBoard, title = (_("Enter your search term(s)")), text = config.plugins.mytube.search.searchTerm.value) + + def ScreenClosed(self): + print "ScreenCLosed, restoring old window state" + if self.currList == "historylist": + if self.HistoryWindow.status() is False: + print "status is FALSE" + self.HistoryWindow.activate() + self.HistoryWindow.instance.show() + elif self.currList == "configlist": + self.switchToConfigList() + ConfigListScreen.keyOK(self) + elif self.currList == "feedlist": + self.switchToFeedList() + + def SearchEntryCallback(self, callback = None): + if callback is not None and len(callback): + config.plugins.mytube.search.searchTerm.value = callback + ConfigListScreen.keyOK(self) + self["config"].getCurrent()[1].getSuggestions() + current = self["config"].getCurrent() + if current[1].help_window.instance is not None: + current[1].help_window.instance.show() + if current[1].suggestionsWindow.instance is not None: + current[1].suggestionsWindow.instance.show() + self.propagateUpDownNormally = True + + def openStandardFeedClosed(self, answer): + answer = answer and answer[1] + print "openStandardFeedClosed - ANSWER",answer + if answer is not None: + if answer == 'hd': + self.FeedURL = "http://gdata.youtube.com/feeds/api/videos/-/HD" + else: + self.FeedURL = self.BASE_STD_FEEDURL + str(answer) + self.setState('getFeed') + self.appendEntries = False + self.getFeed(self.FeedURL, str(answer)) + + def handleLeave(self, how): + self.is_closing = True + if how == "ask": + if self.currList == "configlist": + list = ( + (_("Yes"), "quit"), + (_("No"), "continue"), + (_("No, but switch to video entries."), "switch2feed") + ) + else: + list = ( + (_("Yes"), "quit"), + (_("No"), "continue"), + (_("No, but switch to video search."), "switch2search") + ) + self.session.openWithCallback(self.leavePlayerConfirmed, ChoiceBox, title=_("Really quit MyTube Player?"), list = list) + else: + self.leavePlayerConfirmed([True, how]) + + def leavePlayer(self): + print "self.currList im leavePlayer",self.currList + if self.HistoryWindow is not None: + self.HistoryWindow.deactivate() + self.HistoryWindow.instance.hide() + if self.currList == "configlist": + current = self["config"].getCurrent() + if current[1].suggestionsWindow.activeState is True: + self.propagateUpDownNormally = True + current[1].deactivateSuggestionList() + self["config"].invalidateCurrent() + else: + self.hideSuggestions() + self.handleLeave(config.plugins.mytube.general.on_exit.value) + else: + self.hideSuggestions() + self.handleLeave(config.plugins.mytube.general.on_exit.value) + + def leavePlayerConfirmed(self, answer): + answer = answer and answer[1] + print "ANSWER",answer + if answer == "quit": + cmd = "rm -rf /tmp/*.jpg" + self.CleanupConsole = Console() + self.CleanupConsole.ePopen(cmd, self.doQuit) + elif answer == "continue": + if self.currList == "historylist": + if self.HistoryWindow.status() is False: + print "status is FALSE" + self.HistoryWindow.activate() + self.HistoryWindow.instance.show() + elif self.currList == "configlist": + self.switchToConfigList() + elif self.currList == "feedlist": + self.switchToFeedList() + elif answer == "switch2feed": + self.switchToFeedList() + elif answer == "switch2search": + self.switchToConfigList() + elif answer == None: + print "No menuentry selected, we should just switch back to old state." + if self.currList == "historylist": + if self.HistoryWindow.status() is False: + print "status is FALSE" + self.HistoryWindow.activate() + self.HistoryWindow.instance.show() + elif self.currList == "configlist": + self.switchToConfigList() + elif self.currList == "feedlist": + self.switchToFeedList() + + def doQuit(self, result, retval,extra_args): + if self["config"].getCurrent()[1].suggestionsWindow is not None: + self.session.deleteDialog(self["config"].getCurrent()[1].suggestionsWindow) + if self.HistoryWindow is not None: + self.session.deleteDialog(self.HistoryWindow) + if config.plugins.mytube.general.showHelpOnOpen.value is True: + config.plugins.mytube.general.showHelpOnOpen.value = False + config.plugins.mytube.general.showHelpOnOpen.save() + print "self.History im doQuit:",self.History + if not config.plugins.mytube.general.clearHistoryOnClose.value: + if self.History and len(self.History): + config.plugins.mytube.general.history.value = ",".join(self.History) + else: + config.plugins.mytube.general.history.value = "" + config.plugins.mytube.general.history.save() + config.plugins.mytube.general.save() + config.plugins.mytube.save() + if self.CleanupConsole is not None: + if len(self.CleanupConsole.appContainers): + for name in self.CleanupConsole.appContainers.keys(): + self.CleanupConsole.kill(name) + self.close() + + def keyOK(self): + print "self.currList----->",self.currList + if self.currList == "configlist" or self.currList == "suggestionslist": + self["config"].invalidateCurrent() + if config.plugins.mytube.search.searchTerm.value != "": + self.add2History() + searchContext = config.plugins.mytube.search.searchTerm.value + print "Search searchcontext",searchContext + if isinstance(self["config"].getCurrent()[1], ConfigTextWithGoogleSuggestions) and not self.propagateUpDownNormally: + self.propagateUpDownNormally = True + self["config"].getCurrent()[1].deactivateSuggestionList() + self.setState('getSearchFeed') + self.runSearch(searchContext) + elif self.currList == "feedlist": + current = self[self.currList].getCurrent() + if current: + print current + myentry = current[0] + if myentry is not None: + myurl = myentry.getVideoUrl() + print "Playing URL",myurl + if myurl is not None: + myreference = eServiceReference(4097,0,myurl) + myreference.setName(myentry.getTitle()) + self.session.open(MyTubePlayer, myreference, self.lastservice, infoCallback = self.showVideoInfo, nextCallback = self.getNextEntry, prevCallback = self.getPrevEntry ) + else: + self.session.open(MessageBox, _("Sorry, video is not available!"), MessageBox.TYPE_INFO) + elif self.currList == "historylist": + if self.HistoryWindow is not None: + config.plugins.mytube.search.searchTerm.value = self.HistoryWindow.getSelection() + self["config"].invalidateCurrent() + if config.plugins.mytube.search.searchTerm.value != "": + searchContext = config.plugins.mytube.search.searchTerm.value + print "Search searchcontext",searchContext + self.setState('getSearchFeed') + self.runSearch(searchContext) + + def keyUp(self): + print "self.currList im KeyUp",self.currList + if self.currList == "suggestionslist": + if config.plugins.mytube.search.searchTerm.value != "": + if not self.propagateUpDownNormally: + self["config"].getCurrent()[1].suggestionListUp() + self["config"].invalidateCurrent() + elif self.currList == "feedlist": + self[self.currList].selectPrevious() + elif self.currList == "historylist": + if self.HistoryWindow is not None and self.HistoryWindow.shown: + self.HistoryWindow.up() + + def keyDown(self): + print "self.currList im KeyDown",self.currList + if self.currList == "suggestionslist": + if config.plugins.mytube.search.searchTerm.value != "": + if not self.propagateUpDownNormally: + self["config"].getCurrent()[1].suggestionListDown() + self["config"].invalidateCurrent() + elif self.currList == "feedlist": + print self[self.currList].count() + print self[self.currList].index + if self[self.currList].index == self[self.currList].count()-1 and myTubeService.getNextFeedEntriesURL() is not None: + self.session.openWithCallback(self.getNextEntries, MessageBox, _("Do you want to see more entries?")) + else: + self[self.currList].selectNext() + elif self.currList == "historylist": + if self.HistoryWindow is not None and self.HistoryWindow.shown: + self.HistoryWindow.down() + def keyRight(self): + print "self.currList im KeyRight",self.currList + if self.propagateUpDownNormally: + ConfigListScreen.keyRight(self) + else: + if self.currList == "suggestionslist": + if config.plugins.mytube.search.searchTerm.value != "": + self["config"].getCurrent()[1].suggestionListPageDown() + self["config"].invalidateCurrent() + elif self.currList == "historylist": + if self.HistoryWindow is not None and self.HistoryWindow.shown: + self.HistoryWindow.pageDown() + + def keyLeft(self): + print "self.currList im kEyLeft",self.currList + if self.propagateUpDownNormally: + ConfigListScreen.keyLeft(self) + else: + if self.currList == "suggestionslist": + if config.plugins.mytube.search.searchTerm.value != "": + self["config"].getCurrent()[1].suggestionListPageUp() + self["config"].invalidateCurrent() + elif self.currList == "historylist": + if self.HistoryWindow is not None and self.HistoryWindow.shown: + self.HistoryWindow.pageDown() + def keyStdFeed(self): + self.hideSuggestions() + menulist = [(_("HD videos"), "hd")] + menulist.extend(( + (_("Top rated"), "top_rated"), + (_("Top favorites"), "top_favorites"), + (_("Most viewed"), "most_viewed"), + (_("Most popular"), "most_popular"), + (_("Most recent"), "most_recent"), + (_("Most discussed"), "most_discussed"), + (_("Most linked"), "most_linked"), + (_("Recently featured"), "recently_featured"), + (_("Most responded"), "most_responded") + )) + self.session.openWithCallback(self.openStandardFeedClosed, ChoiceBox, title=_("Select new feed to view."), list = menulist) + + def handleSuggestions(self): + print "handleSuggestions" + print "self.currList",self.currList + if self.currList == "configlist": + self.switchToSuggestionsList() + elif self.currList == "historylist": + if self.HistoryWindow is not None and self.HistoryWindow.shown: + self.HistoryWindow.down() + + def switchToSuggestionsList(self): + print "switchToSuggestionsList" + self.currList = "suggestionslist" + self["ButtonBlue"].hide() + self["VKeyIcon"].hide() + self["statusactions"].setEnabled(False) + self["config_actions"].setEnabled(False) + self["videoactions"].setEnabled(False) + self["searchactions"].setEnabled(False) + self["suggestionactions"].setEnabled(True) + self["historyactions"].setEnabled(False) + self["key_green"].hide() + self.propagateUpDownNormally = False + self["config"].invalidateCurrent() + if self.HistoryWindow is not None and self.HistoryWindow.shown: + self.HistoryWindow.deactivate() + self.HistoryWindow.instance.hide() + + def switchToConfigList(self): + print "switchToConfigList" + self.currList = "configlist" + self["config_actions"].setEnabled(True) + self["historyactions"].setEnabled(False) + self["statusactions"].setEnabled(False) + self["videoactions"].setEnabled(False) + self["suggestionactions"].setEnabled(False) + self["searchactions"].setEnabled(True) + self["key_green"].hide() + self["ButtonBlue"].show() + self["VKeyIcon"].show() + self["config"].invalidateCurrent() + helpwindowpos = self["HelpWindow"].getPosition() + current = self["config"].getCurrent() + if current[1].help_window.instance is not None: + current[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1])) + current[1].help_window.instance.show() + if current[1].suggestionsWindow.instance is not None: + current[1].suggestionsWindow.instance.show() + self["config"].getCurrent()[1].getSuggestions() + self.propagateUpDownNormally = True + if self.HistoryWindow is not None and self.HistoryWindow.shown: + self.HistoryWindow.deactivate() + self.HistoryWindow.instance.hide() + if self.FirstRun == True: + self.handleFirstHelpWindow() + + def switchToFeedList(self, append = False): + print "switchToFeedList" + print "switching to feedlist from:",self.currList + print "len(self.videolist):",len(self.videolist) + if self.HistoryWindow is not None and self.HistoryWindow.shown: + self.HistoryWindow.deactivate() + self.HistoryWindow.instance.hide() + self.hideSuggestions() + if len(self.videolist): + self.currList = "feedlist" + self["ButtonBlue"].hide() + self["VKeyIcon"].hide() + self["videoactions"].setEnabled(True) + self["suggestionactions"].setEnabled(False) + self["searchactions"].setEnabled(False) + self["statusactions"].setEnabled(False) + self["historyactions"].setEnabled(False) + self["key_green"].show() + self["config_actions"].setEnabled(False) + if not append: + self[self.currList].setIndex(0) + else: + self.setState('noVideos') + + + def switchToHistory(self): + print "switchToHistory" + self.oldlist = self.currList + self.currList = "historylist" + print "switchToHistory currentlist",self.currList + print "switchToHistory oldlist",self.oldlist + self.hideSuggestions() + self["ButtonBlue"].hide() + self["VKeyIcon"].hide() + self["key_green"].hide() + self["videoactions"].setEnabled(False) + self["suggestionactions"].setEnabled(False) + self["searchactions"].setEnabled(False) + self["statusactions"].setEnabled(False) + self["config_actions"].setEnabled(False) + self["historyactions"].setEnabled(True) + self.HistoryWindow.activate() + self.HistoryWindow.instance.show() + + def handleHistory(self): + if self.HistoryWindow is None: + self.HistoryWindow = self.session.instantiateDialog(MyTubeHistoryScreen) + if self.currList in ("configlist","feedlist"): + if self.HistoryWindow.status() is False: + print "status is FALSE,switchToHistory" + self.switchToHistory() + elif self.currList == "historylist": + self.closeHistory() + + def closeHistory(self): + print "closeHistory currentlist",self.currList + print "closeHistory oldlist",self.oldlist + if self.currList == "historylist": + if self.HistoryWindow.status() is True: + print "status is TRUE, closing historyscreen" + self.HistoryWindow.deactivate() + self.HistoryWindow.instance.hide() + if self.oldlist == "configlist": + self.switchToConfigList() + elif self.oldlist == "feedlist": + self.switchToFeedList() + + def add2History(self): + if self.History is None: + self.History = config.plugins.mytube.general.history.value.split(',') + if self.History[0] == '': + del self.History[0] + print "self.History im add",self.History + if config.plugins.mytube.search.searchTerm.value in self.History: + self.History.remove((config.plugins.mytube.search.searchTerm.value)) + self.History.insert(0,(config.plugins.mytube.search.searchTerm.value)) + if len(self.History) == 30: + self.History.pop() + config.plugins.mytube.general.history.value = ",".join(self.History) + config.plugins.mytube.general.history.save() + print "configvalue",config.plugins.mytube.general.history.value + + def hideSuggestions(self): + current = self["config"].getCurrent() + if current[1].help_window.instance is not None: + current[1].help_window.instance.hide() + if current[1].suggestionsWindow.instance is not None: + current[1].suggestionsWindow.instance.hide() + self.propagateUpDownNormally = True + + def getFeed(self, feedUrl, feedName): + try: + feed = myTubeService.getFeed(feedUrl) + except Exception, e: + feed = None + print "Error querying feed :",feedName + print "E-->",e + self.setState('Error') + if feed is not None: + self.ytfeed = feed + self.loadPreviewpics() + + def getNextEntries(self, result): + if not result: + return + nextUrl = myTubeService.getNextFeedEntriesURL() + if nextUrl is not None: + self.appendEntries = True + self.getFeed(nextUrl, _("More video entries.")) + + def getRelatedVideos(self, myentry): + if myentry: + myurl = myentry.getRelatedVideos() + print "RELATEDURL--->",myurl + if myurl is not None: + self.getFeed(myurl, _("Related video entries.")) + + def getResponseVideos(self, myentry): + if myentry: + myurl = myentry.getResponseVideos() + print "RESPONSEURL--->",myurl + if myurl is not None: + self.getFeed(myurl, _("Response video entries.")) + + def runSearch(self, searchContext = None): + print "[MyTubePlayer] runSearch" + if searchContext is not None: + print "[MyTubePlayer] searchDialogClosed: ", searchContext + self.searchFeed(searchContext) + + def searchFeed(self, searchContext): + print "[MyTubePlayer] searchFeed" + self.appendEntries = False + try: + feed = myTubeService.search(searchContext, + orderby = config.plugins.mytube.search.orderBy.value, + racy = config.plugins.mytube.search.racy.value, + lr = config.plugins.mytube.search.lr.value, + categories = [ config.plugins.mytube.search.categories.value ], + sortOrder = config.plugins.mytube.search.sortOrder.value) + except Exception, e: + feed = None + print "Error querying search for :",config.plugins.mytube.search.searchTerm.value + print "E-->",e + self.setState('Error') + if feed is not None: + self.ytfeed = feed + if self.FirstRun == True: + self.FirstRun = False + self.loadPreviewpics() + + def loadPreviewpics(self): + self.thumbnails = [] + self.mytubeentries = None + self.index = 0 + self.maxentries = 0 + self.picloads = {} + self.mytubeentries = myTubeService.getEntries() + self.maxentries = len(self.mytubeentries)-1 + if self.mytubeentries and len(self.mytubeentries): + currindex = 0 + for entry in self.mytubeentries: + TubeID = entry.getTubeId() + thumbnailFile = "/tmp/" + str(TubeID) + ".jpg" + currPic = [currindex,TubeID,thumbnailFile,None] + self.thumbnails.append(currPic) + thumbnailUrl = None + thumbnailUrl = entry.getThumbnailUrl(0) + if thumbnailUrl is not None: + client.downloadPage(thumbnailUrl,thumbnailFile).addCallback(self.fetchFinished,currindex,str(TubeID)).addErrback(self.fetchFailed,currindex,str(TubeID)) + currindex +=1 + else: + pass + + def fetchFailed(self, string, index, id): + print "[fetchFailed] for index:" + str(index) + "for YoutubeID:" + id + string.getErrorMessage() + + def fetchFinished(self, string, index, id): + print "[fetchFinished] for index:" + str(index) + " for YoutubeID:" + id + self.decodePic(index) + + def decodePic(self, index): + sc = AVSwitch().getFramebufferScale() + self.picloads[index] = ePicLoad() + self.picloads[index].PictureData.get().append(boundFunction(self.finish_decode, index)) + for entry in self.thumbnails: + if entry[0] == index: + self.index = index + thumbnailFile = entry[2] + if (os_path.exists(thumbnailFile) == True): + #print "[decodePic] DECODING THUMBNAIL for INDEX:"+ str(self.index) + "and file: " + thumbnailFile + self.picloads[index].setPara((self["thumbnail"].instance.size().width(), self["thumbnail"].instance.size().height(), sc[0], sc[1], False, 1, "#00000000")) + self.picloads[index].startDecode(thumbnailFile) + else: + print "[decodePic] Thumbnail file NOT FOUND !!!-->:",thumbnailFile + + def finish_decode(self, picindex = None, picInfo=None): + #print "finish_decode - of INDEX", picindex + ptr = self.picloads[picindex].getData() + if ptr != None: + print ptr + self.thumbnails[picindex][3] = ptr + if (os_path.exists(self.thumbnails[picindex][2]) == True): + #print "removing", self.thumbnails[picindex][2] + remove(self.thumbnails[picindex][2]) + del self.picloads[picindex] + if len(self.picloads) == 0: + self.timer.startLongTimer(3) + + def picloadTimeout(self): + self.timer.stop() + if len(self.picloads) == 0: + print "all decodes should be now really finished" + self.buildEntryList() + else: + self.timer.startLongTimer(2) + + def buildEntryList(self): + myindex = 0 + if self.appendEntries == False: + self.videolist = [] + for entry in self.mytubeentries: + self.videolist.append(self.buildEntryComponent(entry, myindex)) + myindex +=1 + if len(self.videolist): + self["feedlist"].style = "default" + self["feedlist"].disable_callbacks = True + self["feedlist"].list = self.videolist + self["feedlist"].disable_callbacks = False + self["feedlist"].setIndex(0) + self["feedlist"].setList(self.videolist) + self["feedlist"].updateList(self.videolist) + if self.FirstRun == True: + self.switchToConfigList() + else: + self.switchToFeedList() + else: + self.oldfeedentrycount = self["feedlist"].count() + for entry in self.mytubeentries: + self.videolist.append(self.buildEntryComponent(entry, myindex)) + myindex +=1 + if len(self.videolist): + self["feedlist"].style = "default" + old_index = self["feedlist"].index + self["feedlist"].disable_callbacks = True + self["feedlist"].list = self.videolist + self["feedlist"].disable_callbacks = False + self["feedlist"].setList(self.videolist) + self["feedlist"].setIndex(old_index) + self["feedlist"].updateList(self.videolist) + self["feedlist"].selectNext() + self.switchToFeedList(True) + + + def buildEntryComponent(self, entry, index): + Title = entry.getTitle() + print "Titel-->",Title + Description = entry.getDescription() + TubeID = entry.getTubeId() + PublishedDate = entry.getPublishedDate() + if PublishedDate is not "unknown": + published = PublishedDate.split("T")[0] + else: + published = "unknown" + Views = entry.getViews() + if Views is not "not available": + views = Views + else: + views = "not available" + Duration = entry.getDuration() + if Duration is not 0: + durationInSecs = int(Duration) + mins = int(durationInSecs / 60) + secs = durationInSecs - mins * 60 + duration = "%d:%02d" % (mins, secs) + else: + duration = "not available" + Ratings = entry.getNumRaters() + if Ratings is not "": + ratings = Ratings + else: + ratings = "" + thumbnail = self.thumbnails[index][3] + return((entry, Title, Description, TubeID, thumbnail, _("Added: ") + str(published), _("Views: ") + str(views), _("Duration: ") + str(duration), _("Ratings: ") + str(ratings) )) + + def getNextEntry(self): + i = self["feedlist"].getIndex() + 1 + if i < len(self.videolist): + self["feedlist"].selectNext() + current = self["feedlist"].getCurrent() + if current: + myentry = current[0] + if myentry: + myurl = myentry.getVideoUrl() + if myurl is not None: + print "Got a URL to stream" + myreference = eServiceReference(4097,0,myurl) + myreference.setName(myentry.getTitle()) + return myreference,False + else: + print "NoURL im getNextEntry" + return None,True + + print "no more entries to play" + return None,False + + def getPrevEntry(self): + i = self["feedlist"].getIndex() - 1 + if i >= 0: + self["feedlist"].selectPrevious() + current = self["feedlist"].getCurrent() + if current: + myentry = current[0] + if myentry: + myurl = myentry.getVideoUrl() + if myurl is not None: + print "Got a URL to stream" + myreference = eServiceReference(4097,0,myurl) + myreference.setName(myentry.getTitle()) + return myreference,False + else: + return None,True + return None,False + + def showVideoInfo(self): + if self.currList == "feedlist": + cmd = "rm -rf /tmp/*.jpg" + if self.CleanupConsole is None: + self.CleanupConsole = Console() + self.CleanupConsole.ePopen(cmd, self.openInfoScreen) + + def openInfoScreen(self, result, retval,extra_args): + if self.currList == "feedlist": + current = self[self.currList].getCurrent() + if current: + myentry = current[0] + if myentry: + print "Title im showVideoInfo",myentry.getTitle() + videoinfos = myentry.PrintEntryDetails() + self.session.open(MyTubeVideoInfoScreen, self.skin_path, videoinfo = videoinfos ) + + +class MyTubeVideoInfoScreen(Screen): + skin = """ + + + + + + + + {"templates": + {"default": (110,[ + MultiContentEntryPixmapAlphaTest(pos = (0, 4), size = (130, 98), png = 0), # index 0 is the thumbnail + MultiContentEntryPixmapAlphaTest(pos = (130, 4), size = (130, 98), png = 1), # index 0 is the thumbnail + MultiContentEntryPixmapAlphaTest(pos = (260, 4), size = (130, 98), png = 2), # index 0 is the thumbnail + MultiContentEntryPixmapAlphaTest(pos = (390, 4), size = (130, 98), png = 3), # index 0 is the thumbnail + ]), + "state": (110,[ + MultiContentEntryText(pos = (10, 40), size = (550, 38), font=2, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 0), # index 0 is the name + ]) + }, + "fonts": [gFont("Regular", 20),gFont("Regular", 14),gFont("Regular", 28)], + "itemHeight": 110 + } + + + + + + + + + + + + # fake entry for dynamic thumbnail resizing, currently there is no other way doing this. + """ + + def __init__(self, session, plugin_path, videoinfo = None): + Screen.__init__(self, session) + self.session = session + self.skin_path = plugin_path + self.videoinfo = videoinfo + self.infolist = [] + self.thumbnails = [] + self.picloads = {} + self["title"] = Label() + self["key_red"] = Button(_("Close")) + self["thumbnail"] = Pixmap() + self["thumbnail"].hide() + self["detailtext"] = ScrollLabel() + self["starsbg"] = Pixmap() + self["stars"] = ProgressBar() + self["duration"] = Label() + self["author"] = Label() + self["published"] = Label() + self["views"] = Label() + self["tags"] = Label() + self["shortcuts"] = ActionMap(["ShortcutActions", "WizardActions", "MovieSelectionActions"], + { + "back": self.close, + "red": self.close, + "up": self.pageUp, + "down": self.pageDown, + "left": self.pageUp, + "right": self.pageDown, + }, -2) + + self["infolist"] = List(self.infolist) + self.timer = eTimer() + self.timer.callback.append(self.picloadTimeout) + self.onLayoutFinish.append(self.layoutFinished) + self.onShown.append(self.setWindowTitle) + + def layoutFinished(self): + self.statuslist = [] + self.statuslist.append(( _("Downloading screenshots. Please wait..." ),_("Downloading screenshots. Please wait..." ) )) + self["infolist"].style = "state" + self['infolist'].setList(self.statuslist) + self.loadPreviewpics() + if self.videoinfo["Title"] is not None: + self["title"].setText(self.videoinfo["Title"]) + Description = None + if self.videoinfo["Description"] is not None: + Description = self.videoinfo["Description"] + else: + Description = None + if Description is not None: + self["detailtext"].setText(Description.strip()) + + if self.videoinfo["RatingAverage"] is not 0: + ratingStars = int(round(20 * float(self.videoinfo["RatingAverage"]), 0)) + self["stars"].setValue(ratingStars) + else: + self["stars"].hide() + self["starsbg"].hide() + + if self.videoinfo["Duration"] is not 0: + durationInSecs = int(self.videoinfo["Duration"]) + mins = int(durationInSecs / 60) + secs = durationInSecs - mins * 60 + duration = "%d:%02d" % (mins, secs) + self["duration"].setText(_("Duration: ") + str(duration)) + + if self.videoinfo["Author"] is not None or '': + self["author"].setText(_("Author: ") + self.videoinfo["Author"]) + + if self.videoinfo["Published"] is not "unknown": + self["published"].setText(_("Added: ") + self.videoinfo["Published"].split("T")[0]) + + if self.videoinfo["Views"] is not "not available": + self["views"].setText(_("Views: ") + str(self.videoinfo["Views"])) + + if self.videoinfo["Tags"] is not "not available": + self["tags"].setText(_("Tags: ") + str(self.videoinfo["Tags"])) + + def setWindowTitle(self): + self.setTitle(_("MyTubeVideoInfoScreen")) + + def pageUp(self): + self["detailtext"].pageUp() + + def pageDown(self): + self["detailtext"].pageDown() + + def loadPreviewpics(self): + self.thumbnails = [] + self.mythumbubeentries = None + self.index = 0 + self.maxentries = 0 + self.picloads = {} + self.mythumbubeentries = self.videoinfo["Thumbnails"] + self.maxentries = len(self.mythumbubeentries)-1 + if self.mythumbubeentries and len(self.mythumbubeentries): + currindex = 0 + for entry in self.mythumbubeentries: + TubeID = self.videoinfo["TubeID"] + ThumbID = TubeID + str(currindex) + thumbnailFile = "/tmp/" + ThumbID + ".jpg" + currPic = [currindex,ThumbID,thumbnailFile,None] + self.thumbnails.append(currPic) + thumbnailUrl = None + thumbnailUrl = entry + if thumbnailUrl is not None: + client.downloadPage(thumbnailUrl,thumbnailFile).addCallback(self.fetchFinished,currindex,ThumbID).addErrback(self.fetchFailed,currindex,ThumbID) + currindex +=1 + else: + pass + + def fetchFailed(self, string, index, id): + print "[fetchFailed] for index:" + str(index) + "for ThumbID:" + id + string.getErrorMessage() + + def fetchFinished(self, string, index, id): + print "[fetchFinished] for index:" + str(index) + " for ThumbID:" + id + self.decodePic(index) + + def decodePic(self, index): + sc = AVSwitch().getFramebufferScale() + self.picloads[index] = ePicLoad() + self.picloads[index].PictureData.get().append(boundFunction(self.finish_decode, index)) + for entry in self.thumbnails: + if entry[0] == index: + self.index = index + thumbnailFile = entry[2] + if (os_path.exists(thumbnailFile) == True): + print "[decodePic] DECODING THUMBNAIL for INDEX:"+ str(self.index) + "and file: " + thumbnailFile + self.picloads[index].setPara((self["thumbnail"].instance.size().width(), self["thumbnail"].instance.size().height(), sc[0], sc[1], False, 1, "#00000000")) + self.picloads[index].startDecode(thumbnailFile) + else: + print "[decodePic] Thumbnail file NOT FOUND !!!-->:",thumbnailFile + + def finish_decode(self, picindex = None, picInfo=None): + print "finish_decode - of INDEX", picindex + ptr = self.picloads[picindex].getData() + if ptr != None: + print ptr + self.thumbnails[picindex][3] = ptr + if (os_path.exists(self.thumbnails[picindex][2]) == True): + print "removing", self.thumbnails[picindex][2] + remove(self.thumbnails[picindex][2]) + del self.picloads[picindex] + if len(self.picloads) == 0: + self.timer.startLongTimer(3) + + def picloadTimeout(self): + self.timer.stop() + if len(self.picloads) == 0: + print "all decodes should be now really finished" + self.buildInfoList() + else: + self.timer.startLongTimer(2) + + def buildInfoList(self): + print "blasel" + self.infolist = [] + Thumbail0 = None + Thumbail1 = None + Thumbail2 = None + Thumbail3 = None + if self.thumbnails[0][3] is not None: + Thumbail0 = self.thumbnails[0][3] + if self.thumbnails[1][3] is not None: + Thumbail1 = self.thumbnails[1][3] + if self.thumbnails[2][3] is not None: + Thumbail2 = self.thumbnails[2][3] + if self.thumbnails[3][3] is not None: + Thumbail3 = self.thumbnails[3][3] + self.infolist.append(( Thumbail0, Thumbail1, Thumbail2, Thumbail3)) + if len(self.infolist): + self["infolist"].style = "default" + self["infolist"].disable_callbacks = True + self["infolist"].list = self.infolist + self["infolist"].disable_callbacks = False + self["infolist"].setIndex(0) + self["infolist"].setList(self.infolist) + self["infolist"].updateList(self.infolist) + + +class MyTubeVideoHelpScreen(Screen): + skin = """ + + + + + + + + """ + + def __init__(self, session, plugin_path, wantedinfo = None, wantedtitle = None): + Screen.__init__(self, session) + self.session = session + self.skin_path = plugin_path + self.wantedinfo = wantedinfo + self.wantedtitle = wantedtitle + self["title"] = Label() + self["key_red"] = Button(_("Close")) + self["detailtext"] = ScrollLabel() + + self["shortcuts"] = ActionMap(["ShortcutActions", "WizardActions"], + { + "back": self.close, + "red": self.close, + "up": self.pageUp, + "down": self.pageDown, + "left": self.pageUp, + "right": self.pageDown, + }, -2) + + self.onLayoutFinish.append(self.layoutFinished) + self.onShown.append(self.setWindowTitle) + + def layoutFinished(self): + if self.wantedtitle is None: + self["title"].setText(_("Help")) + else: + self["title"].setText(self.wantedtitle) + if self.wantedinfo is None: + self["detailtext"].setText(_("This is the help screen. Feed me with something to display.")) + else: + self["detailtext"].setText(self.wantedinfo) + + def setWindowTitle(self): + self.setTitle(_("MyTubeVideohelpScreen")) + + def pageUp(self): + self["detailtext"].pageUp() + + def pageDown(self): + self["detailtext"].pageDown() + + +class MyTubePlayer(Screen, InfoBarNotifications): + STATE_IDLE = 0 + STATE_PLAYING = 1 + STATE_PAUSED = 2 + ENABLE_RESUME_SUPPORT = True + ALLOW_SUSPEND = True + + skin = """ + + + + + + Name + + + Length + + + Position + + + Gauge + + + Remaining + + """ + + def __init__(self, session, service, lastservice, infoCallback = None, nextCallback = None, prevCallback = None): + Screen.__init__(self, session) + InfoBarNotifications.__init__(self) + self.session = session + self.service = service + self.infoCallback = infoCallback + self.nextCallback = nextCallback + self.prevCallback = prevCallback + self.screen_timeout = 5000 + self.nextservice = None + + print "evEOF=%d" % iPlayableService.evEOF + self.__event_tracker = ServiceEventTracker(screen = self, eventmap = + { + iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged, + iPlayableService.evStart: self.__serviceStarted, + iPlayableService.evEOF: self.__evEOF, + }) + + self["actions"] = ActionMap(["OkCancelActions", "InfobarSeekActions", "MediaPlayerActions", "MovieSelectionActions"], + { + "ok": self.ok, + "cancel": self.leavePlayer, + "stop": self.leavePlayer, + "playpauseService": self.playpauseService, + "seekFwd": self.playNextFile, + "seekBack": self.playPrevFile, + "showEventInfo": self.showVideoInfo, + }, -2) + + + self.lastservice = lastservice + + self.hidetimer = eTimer() + self.hidetimer.timeout.get().append(self.ok) + self.returning = False + + self.state = self.STATE_PLAYING + self.lastseekstate = self.STATE_PLAYING + + self.onPlayStateChanged = [ ] + self.__seekableStatusChanged() + + self.play() + self.onClose.append(self.__onClose) + + def __onClose(self): + self.session.nav.stopService() + + def __evEOF(self): + print "evEOF=%d" % iPlayableService.evEOF + print "Event EOF" + self.handleLeave(config.plugins.mytube.general.on_movie_stop.value) + + def __setHideTimer(self): + self.hidetimer.start(self.screen_timeout) + + def showInfobar(self): + self.show() + if self.state == self.STATE_PLAYING: + self.__setHideTimer() + else: + pass + + def hideInfobar(self): + self.hide() + self.hidetimer.stop() + + def ok(self): + if self.shown: + self.hideInfobar() + else: + self.showInfobar() + + def showVideoInfo(self): + if self.shown: + self.hideInfobar() + if self.infoCallback is not None: + self.infoCallback() + + + def playNextFile(self): + print "playNextFile" + nextservice,error = self.nextCallback() + print "nextservice--->",nextservice + if nextservice is None: + self.handleLeave(config.plugins.mytube.general.on_movie_stop.value, error) + else: + self.playService(nextservice) + self.showInfobar() + + def playPrevFile(self): + print "playPrevFile" + prevservice,error = self.prevCallback() + if prevservice is None: + self.handleLeave(config.plugins.mytube.general.on_movie_stop.value, error) + else: + self.playService(prevservice) + self.showInfobar() + + def playagain(self): + print "playagain" + if self.state != self.STATE_IDLE: + self.stopCurrent() + self.play() + + def playService(self, newservice): + if self.state != self.STATE_IDLE: + self.stopCurrent() + self.service = newservice + self.play() + + def play(self): + if self.state == self.STATE_PAUSED: + if self.shown: + self.__setHideTimer() + self.state = self.STATE_PLAYING + print "self.state--->",self.state + self.session.nav.playService(self.service) + if self.shown: + self.__setHideTimer() + + def stopCurrent(self): + print "stopCurrent" + self.session.nav.stopService() + #if self.state == self.STATE_IDLE: + # return + self.state = self.STATE_IDLE + print "self.state--->",self.state + + + def playpauseService(self): + print "playpauseService" + #print "self.state--->",self.state + if self.state == self.STATE_PLAYING: + self.pauseService() + elif self.state == self.STATE_PAUSED: + self.unPauseService() + + def pauseService(self): + print "pauseService" + if self.state == self.STATE_PLAYING: + #print "self.state--->",self.state + print "calling setseekstate pause" + self.setSeekState(self.STATE_PAUSED) + + def unPauseService(self): + print "unPauseService" + if self.state == self.STATE_PAUSED: + #print "self.state--->",self.state + print "calling setseekstate playing" + self.setSeekState(self.STATE_PLAYING) + + + def getSeek(self): + service = self.session.nav.getCurrentService() + if service is None: + return None + + seek = service.seek() + + if seek is None or not seek.isCurrentlySeekable(): + return None + + return seek + + def isSeekable(self): + if self.getSeek() is None: + return False + return True + + def __seekableStatusChanged(self): + print "seekable status changed!" + if not self.isSeekable(): + #self["SeekActions"].setEnabled(False) + print "not seekable, return to play" + self.setSeekState(self.STATE_PLAYING) + else: +# self["SeekActions"].setEnabled(True) + print "seekable" + + def __serviceStarted(self): + self.state = self.STATE_PLAYING + self.__seekableStatusChanged() + + def setSeekState(self, wantstate): + print "setSeekState" + #print "current state--->",self.state + #print " wanted state--->",wantstate + if wantstate == self.STATE_PAUSED: + print "trying to switch to Pause- state:",self.STATE_PAUSED + elif wantstate == self.STATE_PLAYING: + print "trying to switch to playing- state:",self.STATE_PLAYING + service = self.session.nav.getCurrentService() + if service is None: + print "No Service found" + return False + pauseable = service.pause() + if pauseable is None: + print "not pauseable." + self.state = self.STATE_PLAYING + + if pauseable is not None: + print "service is pausable" + if wantstate == self.STATE_PAUSED: + print "WANT TO PAUSE" + print "current state --->",self.state + print "wanted state --->",wantstate + pauseable.pause() + self.state = self.STATE_PAUSED + if not self.shown: + self.hidetimer.stop() + self.show() + elif wantstate == self.STATE_PLAYING: + print "WANT TO PLAY" + print "current state --->",self.state + print "wanted state --->",wantstate + pauseable.unpause() + self.state = self.STATE_PLAYING + if self.shown: + self.__setHideTimer() + + for c in self.onPlayStateChanged: + c(self.state) + + return True + + def handleLeave(self, how, error = False): + self.is_closing = True + if how == "ask": + list = ( + (_("Yes"), "quit"), + (_("No, but play video again"), "playagain"), + (_("Yes, but play next video"), "playnext"), + (_("Yes, but play previous video"), "playprev"), + ) + if error is False: + self.session.openWithCallback(self.leavePlayerConfirmed, ChoiceBox, title=_("Stop playing this movie?"), list = list) + else: + self.session.openWithCallback(self.leavePlayerConfirmed, ChoiceBox, title=_("No playable video found! Stop playing this movie?"), list = list) + else: + self.leavePlayerConfirmed([True, how]) + + def leavePlayer(self): + self.handleLeave(config.plugins.mytube.general.on_movie_stop.value) + + def leavePlayerConfirmed(self, answer): + answer = answer and answer[1] + print "ANSWER im player leave",answer + if answer == "quit": + self.close() + elif answer == "playnext": + self.playNextFile() + elif answer == "playprev": + self.playPrevFile() + elif answer == "playagain": + self.playagain() + + def doEofInternal(self, playing): + if not self.execing: + return + if not playing : + return + self.handleLeave(config.usage.on_movie_eof.value) + + +def MyTubeMain(session, **kwargs): + Console().ePopen(("rm -rf /tmp/*.jpg")) + session.open(MyTubePlayerMainScreen) + + +def Plugins(path, **kwargs): + global plugin_path + plugin_path = path + return PluginDescriptor( + name=_("My TubePlayer"), + description=_("Play YouTube movies"), + where = [ PluginDescriptor.WHERE_EXTENSIONSMENU, PluginDescriptor.WHERE_PLUGINMENU ], + icon = "plugin.png", fnc = MyTubeMain)