Exemple #1
0
 def waitForChange(self):
     scutils.KODISCLib.sleep(200)
     while True:
         if xbmc.abortRequested or not sctop.isPlaying():
             return
         pom = xbmc.getInfoLabel('Player.FinishTime(hh:mm:ss)')
         if pom != self.estimateFinishTime:
             self.estimateFinishTime = pom
             break
         scutils.KODISCLib.sleep(100)
Exemple #2
0
 def timeRatio(self):
     if sctop.isPlaying():
         self.watchedTime = self.getTime()
         self.itemDuration = self.getTotalTime()
     try:
         util.debug("[SC] watched %f duration %f" %
                    (self.watchedTime, self.itemDuration))
         return float("%.3f" %
                      (self.watchedTime / math.floor(self.itemDuration)))
     except Exception as e:
         util.debug("[SC] timeRatio error")
         util.debug(e)
         pass
     try:
         self.realFinishTime = xbmc.getInfoLabel(
             'Player.FinishTime(hh:mm:ss)')
         return (self.get_sec(self.estimateFinishTime).seconds - \
             self.get_sec(self.realFinishTime).seconds) / \
             math.floor(self.itemDuration)
     except:
         return None
Exemple #3
0
    def onPlayBackStarted(self):
        if self.scid is not None:
            self.onPlayBackStopped()
        self.upNextEnable = True
        self.se = None
        self.ep = None
        self.libItem = None
        self.watchedTime = 0
        util.debug("[SC] Zacalo sa prehravat")
        mojPlugin = self.win.getProperty(sctop.__scriptid__)
        if sctop.__scriptid__ not in mojPlugin:
            util.debug("[SC] Nieje to moj plugin ... ")
            return
        util.debug("[SC] JE to moj plugin ... %s" % str(mojPlugin))
        self.scid = self.win.getProperty('scid')
        try:
            self.ids = json.loads(
                self.win.getProperty('%s.ids' % sctop.__scriptid__))
        except:
            self.ids = {}
            pass
        try:
            stream = json.loads(
                self.win.getProperty('%s.stream' % sctop.__scriptid__))
            util.debug("[SC] stream %s" % str(stream))
        except:
            stream = {}
            pass

        self.stream = stream
        self.win.clearProperty(sctop.__scriptid__)
        self.win.clearProperty('%s.ids' % sctop.__scriptid__)
        self.win.clearProperty('%s.stream' % sctop.__scriptid__)
        self.win.clearProperty('scid')
        self.win.clearProperty('scresume')
        try:
            if sctop.getSettingAsBool('filter_audio'):
                util.debug("[SC] skusam vybrat spravne audio")
                self.selectAudio()
            else:
                util.debug("[SC] nemame filter pre audio")
        except:
            util.debug(
                "[SC] XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
            )
            pass

        try:
            if not sctop.isPlaying():
                util.debug(
                    '[SC] NEPREHRAVA, TAK KONCIM!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
                )
                return

            self.itemDuration = self.getTotalTime()
            # plánovaný čas dokončení 100 % přehrání
            self.estimateFinishTime = xbmc.getInfoLabel(
                'Player.FinishTime(hh:mm:ss)')
            if 'originaltitle' in stream:
                season = stream.get('season')
                episode = stream.get('episode')
                if episode is not None and season is not None:
                    showtitle = stream.get('originaltitle')
                else:
                    showtitle = None
                year = stream.get('year')
                title = stream.get('originaltitle')
                try:
                    imdb = 'tt%07d' % int(stream.get('imdb')) if stream.get(
                        'imdb').isdigit() else None
                except:
                    imdb = None
                    util.debug("[SC] imdb %s" % str(traceback.format_exc()))
                self.se = season
                self.ep = episode
            else:
                season = xbmc.getInfoLabel('VideoPlayer.Season')
                episode = xbmc.getInfoLabel('VideoPlayer.Episode')
                self.se = season
                self.ep = episode
                showtitle = xbmc.getInfoLabel('VideoPlayer.TVShowTitle')
                year = xbmc.getInfoLabel('VideoPlayer.Year')
                title = xbmc.getInfoLabel('VideoPlayer.Title')
                imdb = xbmc.getInfoLabel(
                    "VideoPlayer.IMDBNumber")  #"ListItem.IMDBNumber")

            if episode is not None:
                util.debug("[SC] Serial")
                self.itemType = 'episode'
            else:
                util.debug("[SC] Film")
                self.itemType = 'movie'

            try:
                if self.itemType == 'movie':
                    self.addLast('lastm', self.scid)
                    method = 'VideoLibrary.GetMovies'
                    try:
                        if self.ids is not None and trakt.getTraktCredentialsInfo(
                        ) == True:
                            #trakt.addTraktCollection({'movies':[{'ids':self.ids}]})
                            pass
                    except:
                        util.debug(
                            "[SC] trakt.tv error - nepodarilo sa pridat film do kolekcie: %s"
                            % str(traceback.format_exc()))
                        pass
                    value = "%s (%s).strm" % (self.parent.normalize_filename(
                        str(title)), str(year))
                    field = 'filename'
                    res = self.executeJSON({
                        'jsonrpc': '2.0',
                        'method': method,
                        'params': {
                            'filter': {
                                'operator': 'contains',
                                'field': field,
                                'value': value
                            },
                            'properties': ['file', 'resume'],
                        },
                        'id': 1
                    })

                    if 'result' in res and 'movies' in res['result']:
                        for m in res['result']['movies']:
                            util.debug("[SC] m: %s" % str(m))
                            if 'movieid' in m:
                                self.libItem = m
                                self.itemDBID = m['movieid']
                                break
                else:
                    self.addLast('last', self.scid)
                    if self.ids is not None and trakt.getTraktCredentialsInfo(
                    ) == True:
                        #trakt.addTraktCollection({'shows':[{'ids':self.ids}]})
                        pass

                    method = 'VideoLibrary.GetTVShows'
                    value = self.parent.normalize_filename(
                        str(showtitle)
                    )  #/Season %s/%sx%s.strm" % (showtitle, season, season, episode)
                    field = 'path'
                    res = self.executeJSON({
                        'jsonrpc': '2.0',
                        'method': method,
                        'params': {
                            'filter': {
                                'operator': 'contains',
                                'field': field,
                                'value': value
                            }
                        },
                        'id': 1
                    })

                    if 'result' in res:
                        for m in res['result']['tvshows']:
                            if 'tvshowid' in m:
                                self.itemDBID = int(m['tvshowid'])
                                res = self.executeJSON({
                                    'jsonrpc': '2.0',
                                    'method': 'VideoLibrary.GetEpisodes',
                                    'params': {
                                        'tvshowid': int(m['tvshowid']),
                                        'season': int(season),
                                        'properties':
                                        ['episode', 'file', 'resume'],
                                        'sort': {
                                            'method': 'episode'
                                        }
                                    },
                                    'id': 1
                                })
                                util.info("[SC] tvshow json: %s" % str(res))
                                for e in res['result']['episodes']:
                                    if int(e['episode']) == int(episode):
                                        self.libItem = e
                                        self.itemDBID = e['episodeid']
                                        break
                                break

            except Exception:
                util.debug("[SC] Chyba JSONRPC: %s" %
                           str(traceback.format_exc()))
                pass

            res = self.executeJSON({
                'jsonrpc': '2.0',
                'method': 'Player.GetItem',
                'params': {
                    'playerid': 1
                },
                'id': 1
            })
            if res:
                _filename = None
                try:
                    _filename = os.path.basename(self.getPlayingFile())
                except:
                    util.debug(
                        "[SC] onPlayBackStarted() - Exception trying to get playing filename, player suddenly stopped."
                    )
                    return
                util.debug(
                    "[SC] Zacalo sa prehravat: DBID: [%s], SCID: [%s] imdb: %s dur: %s est: %s fi: [%s] | %sx%s - title: %s (year: %s) showtitle: %s"
                    % (str(self.itemDBID), str(
                        self.scid), str(imdb), str(self.itemDuration),
                       self.estimateFinishTime, _filename, str(season),
                       str(episode), str(title), str(year), str(showtitle)))
                data = {
                    'scid': self.scid,
                    'action': 'start',
                    'ep': episode,
                    'se': season
                }
                util.debug("[SC] prehravanie %s" % str(res))

                self.action(data)
                if 'item' in res and 'id' not in res['item']:
                    util.debug("[SC] prehravanie mimo kniznice")
        except Exception:
            util.debug("[SC] Chyba MyPlayer: %s" % str(traceback.format_exc()))
            pass

        try:
            if 'resume' in self.libItem and sctop.win.getProperty(
                    'sc.resume') == 'true':
                util.debug("[SC] resume! %s" % str(self.libItem))
                pos = self.libItem['resume'].get('position', 0)
                maxPos = self.getTotalTime() * .75
                if pos > 3 * 60 and pos < maxPos:
                    self.seekTime(pos)
        except:
            pass