277 lines
11 KiB
Python
277 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
from __future__ import absolute_import, division, unicode_literals
|
|
from logging import getLogger
|
|
|
|
import xbmc
|
|
|
|
from .plex_api import API
|
|
from .playutils import PlayUtils
|
|
from .windows.resume import resume_dialog
|
|
from . import app, plex_functions as PF, utils, json_rpc, variables as v, \
|
|
widgets, playlist_func as PL, playqueue as PQ
|
|
|
|
|
|
LOG = getLogger('PLEX.playstrm')
|
|
|
|
|
|
class PlayStrmException(Exception):
|
|
"""
|
|
Any Exception associated with playstrm
|
|
"""
|
|
pass
|
|
|
|
|
|
class PlayStrm(object):
|
|
'''
|
|
Workflow: Strm that calls our webservice in database. When played, the
|
|
webserivce returns a dummy file to play. Meanwhile, PlayStrm adds the real
|
|
listitems for items to play to the playlist.
|
|
'''
|
|
def __init__(self, params, server_id=None):
|
|
LOG.debug('Starting PlayStrm with server_id %s, params: %s',
|
|
server_id, params)
|
|
self.xml = None
|
|
self.playqueue_item = None
|
|
self.api = None
|
|
self.start_index = None
|
|
self.index = None
|
|
self.server_id = server_id
|
|
self.plex_id = utils.cast(int, params['plex_id'])
|
|
self.plex_type = params.get('plex_type')
|
|
if params.get('synched') and params['synched'].lower() == 'false':
|
|
self.synched = False
|
|
else:
|
|
self.synched = True
|
|
self.kodi_id = utils.cast(int, params.get('kodi_id'))
|
|
self.kodi_type = params.get('kodi_type')
|
|
self._get_xml()
|
|
self.name = self.api.title()
|
|
if ((self.kodi_id is None or self.kodi_type is None) and
|
|
self.xml[0].get('pkc_db_item')):
|
|
self.kodi_id = self.xml[0].get('pkc_db_item')['kodi_id']
|
|
self.kodi_type = self.xml[0].get('pkc_db_item')['kodi_type']
|
|
self.transcode = params.get('transcode')
|
|
if self.transcode is None:
|
|
self.transcode = utils.settings('playFromTranscode.bool') if utils.settings('playFromStream.bool') else None
|
|
if app.PLAYSTATE.audioplaylist:
|
|
LOG.debug('Audio playlist detected')
|
|
self.playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_AUDIO)
|
|
else:
|
|
LOG.debug('Video playlist detected')
|
|
self.playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_VIDEO)
|
|
self.kodi_playlist = self.playqueue.kodi_pl
|
|
|
|
def __repr__(self):
|
|
return ("{{"
|
|
"'name': '{self.name}', "
|
|
"'plex_id': {self.plex_id}, "
|
|
"'plex_type': '{self.plex_type}', "
|
|
"'kodi_id': {self.kodi_id}, "
|
|
"'kodi_type': '{self.kodi_type}', "
|
|
"'server_id': '{self.server_id}', "
|
|
"'transcode': {self.transcode}, "
|
|
"'start_index': {self.start_index}, "
|
|
"'index': {self.index}"
|
|
"}}").format(self=self).encode('utf-8')
|
|
__str__ = __repr__
|
|
|
|
def playlist_add_json(self):
|
|
playlistid = self.kodi_playlist.getPlayListId()
|
|
LOG.debug('Adding kodi_id %s, kodi_type %s to playlist %s at index %s',
|
|
self.kodi_id, self.kodi_type, playlistid, self.index)
|
|
if self.index is None:
|
|
json_rpc.playlist_add(playlistid,
|
|
{'%sid' % self.kodi_type: self.kodi_id})
|
|
else:
|
|
json_rpc.playlist_insert({'playlistid': playlistid,
|
|
'position': self.index,
|
|
'item': {'%sid' % self.kodi_type: self.kodi_id}})
|
|
|
|
def playlist_add(self, url, listitem):
|
|
self.kodi_playlist.add(url=url, listitem=listitem, index=self.index)
|
|
self.playqueue_item.file = url.decode('utf-8')
|
|
self.playqueue.items.insert(self.index, self.playqueue_item)
|
|
self.index += 1
|
|
|
|
def remove_from_playlist(self, index):
|
|
LOG.debug('Removing playlist item number %s from %s', index, self)
|
|
json_rpc.playlist_remove(self.kodi_playlist.getPlayListId(),
|
|
index)
|
|
|
|
def _get_xml(self):
|
|
self.xml = PF.GetPlexMetadata(self.plex_id)
|
|
if self.xml in (None, 401):
|
|
raise PlayStrmException('No xml received from the PMS')
|
|
if self.synched:
|
|
# Adds a new key 'pkc_db_item' to self.xml[0].attrib
|
|
widgets.attach_kodi_ids(self.xml)
|
|
else:
|
|
self.xml[0].set('pkc_db_item', None)
|
|
self.api = API(self.xml[0])
|
|
|
|
def set_playqueue_item(self, xml, kodi_id, kodi_type):
|
|
self.playqueue_item = PL.playlist_item_from_xml(xml,
|
|
kodi_id=kodi_id,
|
|
kodi_type=kodi_type)
|
|
self.playqueue_item.force_transcode = self.transcode
|
|
|
|
def start_playback(self, index=0):
|
|
LOG.debug('Starting playback at %s', index)
|
|
xbmc.Player().play(self.kodi_playlist, startpos=index, windowed=False)
|
|
|
|
def play(self, start_position=None, delayed=True):
|
|
'''
|
|
Create and add listitems to the Kodi playlist.
|
|
'''
|
|
LOG.debug('play called with start_position %s, delayed %s',
|
|
start_position, delayed)
|
|
if start_position is not None:
|
|
self.start_index = start_position
|
|
else:
|
|
self.start_index = max(self.kodi_playlist.getposition(), 0)
|
|
self.index = self.start_index
|
|
self._set_playlist()
|
|
LOG.info('Initiating play for %s', self)
|
|
if not delayed:
|
|
self.start_playback(self.start_index)
|
|
return self.index
|
|
|
|
def play_folder(self, position=None):
|
|
'''
|
|
When an entire queue is requested, If requested from Kodi, kodi_type is
|
|
provided, add as Kodi would, otherwise queue playlist items using strm
|
|
links to setup playback later.
|
|
'''
|
|
self.start_index = position or max(self.kodi_playlist.size(), 0)
|
|
self.index = self.start_index + 1
|
|
LOG.info('Play folder plex_id %s, index: %s', self.plex_id, self.index)
|
|
if self.kodi_id and self.kodi_type:
|
|
self.playlist_add_json()
|
|
self.index += 1
|
|
else:
|
|
listitem = widgets.get_listitem(self.xml[0], resume=True)
|
|
url = 'http://127.0.0.1:%s/plex/play/file.strm' % v.WEBSERVICE_PORT
|
|
args = {
|
|
'plex_id': self.plex_id,
|
|
'plex_type': self.api.plex_type()
|
|
}
|
|
if self.kodi_id:
|
|
args['kodi_id'] = self.kodi_id
|
|
if self.kodi_type:
|
|
args['kodi_type'] = self.kodi_type
|
|
if self.server_id:
|
|
args['server_id'] = self.server_id
|
|
if self.transcode:
|
|
args['transcode'] = 'true'
|
|
url = utils.extend_url(url, args).encode('utf-8')
|
|
listitem.setPath(url)
|
|
self.playlist_add(url, listitem)
|
|
return self.index - 1
|
|
|
|
def _set_playlist(self):
|
|
'''
|
|
Verify seektime, set intros, set main item and set additional parts.
|
|
Detect the seektime for video type content. Verify the default video
|
|
action set in Kodi for accurate resume behavior.
|
|
'''
|
|
seektime = self._resume()
|
|
trailers = False
|
|
if (not seektime and self.plex_type == v.PLEX_TYPE_MOVIE and
|
|
utils.settings('enableCinema') == 'true'):
|
|
if utils.settings('askCinema') == "true":
|
|
# "Play trailers?"
|
|
trailers = utils.yesno_dialog(utils.lang(29999),
|
|
utils.lang(33016)) or False
|
|
else:
|
|
trailers = True
|
|
LOG.debug('Playing trailers: %s', trailers)
|
|
xml = PF.init_plex_playqueue(self.plex_id,
|
|
self.xml.get('librarySectionUUID'),
|
|
mediatype=self.plex_type,
|
|
trailers=trailers)
|
|
if xml is None:
|
|
LOG.error('Could not get playqueue for UUID %s for %s',
|
|
self.xml.get('librarySectionUUID'), self)
|
|
# "Play error"
|
|
utils.dialog('notification',
|
|
utils.lang(29999),
|
|
utils.lang(30128),
|
|
icon='{error}')
|
|
app.PLAYSTATE.context_menu_play = False
|
|
app.PLAYSTATE.resume_playback = False
|
|
return
|
|
PL.get_playlist_details_from_xml(self.playqueue, xml)
|
|
# See that we add trailers, if they exist in the xml return
|
|
self._add_intros(xml)
|
|
# Add the main item
|
|
if seektime:
|
|
listitem = widgets.get_listitem(self.xml[0], resume=True)
|
|
else:
|
|
listitem = widgets.get_listitem(self.xml[0], resume=False)
|
|
listitem.setSubtitles(self.api.cache_external_subs())
|
|
self.set_playqueue_item(self.xml[0], self.kodi_id, self.kodi_type)
|
|
play = PlayUtils(self.api, self.playqueue_item)
|
|
url = play.getPlayUrl().encode('utf-8')
|
|
listitem.setPath(url)
|
|
self.playlist_add(url, listitem)
|
|
# Add additional file parts, if any exist
|
|
self._add_additional_parts()
|
|
|
|
def _resume(self):
|
|
'''
|
|
Resume item if available. Returns bool or raise an PlayStrmException if
|
|
resume was cancelled by user.
|
|
'''
|
|
seektime = app.PLAYSTATE.resume_playback
|
|
app.PLAYSTATE.resume_playback = None
|
|
if app.PLAYSTATE.autoplay:
|
|
seektime = False
|
|
LOG.info('Skip resume for autoplay')
|
|
elif seektime is None:
|
|
resume = self.api.resume_point()
|
|
if resume:
|
|
seektime = resume_dialog(resume)
|
|
LOG.info('User chose resume: %s', seektime)
|
|
if seektime is None:
|
|
raise PlayStrmException('User backed out of resume dialog.')
|
|
app.PLAYSTATE.autoplay = True
|
|
return seektime
|
|
|
|
def _add_intros(self, xml):
|
|
'''
|
|
if we have any play them when the movie/show is not being resumed.
|
|
'''
|
|
if not len(xml) > 1:
|
|
LOG.debug('No trailers returned from the PMS')
|
|
return
|
|
for intro in xml:
|
|
api = API(intro)
|
|
if not api.plex_type() == v.PLEX_TYPE_CLIP:
|
|
# E.g. the main item we're looking at - skip!
|
|
continue
|
|
LOG.debug('Adding trailer: %s', api.title())
|
|
listitem = widgets.get_listitem(intro, resume=False)
|
|
self.set_playqueue_item(intro, None, None)
|
|
play = PlayUtils(api, self.playqueue_item)
|
|
url = play.getPlayUrl().encode('utf-8')
|
|
listitem.setPath(url)
|
|
self.playlist_add(url, listitem)
|
|
|
|
def _add_additional_parts(self):
|
|
''' Create listitems and add them to the stack of playlist.
|
|
'''
|
|
for part, _ in enumerate(self.xml[0][0]):
|
|
if part == 0:
|
|
# The first part that we've already added
|
|
continue
|
|
self.api.set_part_number(part)
|
|
LOG.debug('Adding addional part %s', part)
|
|
self.set_playqueue_item(self.xml[0], self.kodi_id, self.kodi_type)
|
|
self.playqueue_item.part = part
|
|
listitem = widgets.get_listitem(self.xml[0], resume=False)
|
|
listitem.setSubtitles(self.api.cache_external_subs())
|
|
playqueue_item = PL.playlist_item_from_xml(self.xml[0])
|
|
play = PlayUtils(self.api, playqueue_item)
|
|
url = play.getPlayUrl().encode('utf-8')
|
|
listitem.setPath(url)
|
|
self.playlist_add(url, listitem)
|