159 lines
5.8 KiB
Python
159 lines
5.8 KiB
Python
# -*- coding: utf-8 -*-
|
|
###############################################################################
|
|
from logging import getLogger
|
|
from threading import Thread
|
|
from urlparse import parse_qsl
|
|
|
|
from xbmc import Player
|
|
|
|
from PKC_listitem import PKC_ListItem
|
|
from pickler import pickle_me, Playback_Successful
|
|
from playbackutils import PlaybackUtils
|
|
import playback
|
|
from utils import window
|
|
from PlexFunctions import GetPlexMetadata
|
|
from PlexAPI import API
|
|
import playqueue as PQ
|
|
import variables as v
|
|
from downloadutils import DownloadUtils
|
|
from PKC_listitem import convert_PKC_to_listitem
|
|
import plexdb_functions as plexdb
|
|
from context_entry import ContextMenu
|
|
import state
|
|
|
|
###############################################################################
|
|
|
|
LOG = getLogger("PLEX." + __name__)
|
|
|
|
###############################################################################
|
|
|
|
|
|
class Playback_Starter(Thread):
|
|
"""
|
|
Processes new plays
|
|
"""
|
|
def process_play(self, plex_id, kodi_id=None):
|
|
"""
|
|
Processes Kodi playback init for ONE item
|
|
"""
|
|
LOG.info("Process_play called with plex_id %s, kodi_id %s",
|
|
plex_id, kodi_id)
|
|
if not state.AUTHENTICATED:
|
|
LOG.error('Not yet authenticated for PMS, abort starting playback')
|
|
# Todo: Warn user with dialog
|
|
return
|
|
xml = GetPlexMetadata(plex_id)
|
|
try:
|
|
xml[0].attrib
|
|
except (IndexError, TypeError, AttributeError):
|
|
LOG.error('Could not get a PMS xml for plex id %s', plex_id)
|
|
return
|
|
api = API(xml[0])
|
|
if api.getType() == v.PLEX_TYPE_PHOTO:
|
|
# Photo
|
|
result = Playback_Successful()
|
|
listitem = PKC_ListItem()
|
|
listitem = api.CreateListItemFromPlexItem(listitem)
|
|
result.listitem = listitem
|
|
else:
|
|
# Video and Music
|
|
playqueue = PQ.get_playqueue_from_type(
|
|
v.KODI_PLAYLIST_TYPE_FROM_PLEX_TYPE[api.getType()])
|
|
with PQ.LOCK:
|
|
result = PlaybackUtils(xml, playqueue).play(
|
|
plex_id,
|
|
kodi_id,
|
|
xml.attrib.get('librarySectionUUID'))
|
|
LOG.info('Done process_play, playqueues: %s', PQ.PLAYQUEUES)
|
|
return result
|
|
|
|
def process_plex_node(self, url, viewOffset, directplay=False,
|
|
node=True):
|
|
"""
|
|
Called for Plex directories or redirect for playback (e.g. trailers,
|
|
clips, watchlater)
|
|
"""
|
|
LOG.info('process_plex_node called with url: %s, viewOffset: %s',
|
|
url, viewOffset)
|
|
# Plex redirect, e.g. watch later. Need to get actual URLs
|
|
if url.startswith('http') or url.startswith('{server}'):
|
|
xml = DownloadUtils().downloadUrl(url)
|
|
else:
|
|
xml = DownloadUtils().downloadUrl('{server}%s' % url)
|
|
try:
|
|
xml[0].attrib
|
|
except:
|
|
LOG.error('Could not download PMS metadata')
|
|
return
|
|
if viewOffset != '0':
|
|
try:
|
|
viewOffset = int(v.PLEX_TO_KODI_TIMEFACTOR * float(viewOffset))
|
|
except:
|
|
pass
|
|
else:
|
|
window('plex_customplaylist.seektime', value=str(viewOffset))
|
|
LOG.info('Set resume point to %s', viewOffset)
|
|
api = API(xml[0])
|
|
typus = v.KODI_PLAYLIST_TYPE_FROM_PLEX_TYPE[api.getType()]
|
|
if node is True:
|
|
plex_id = None
|
|
kodi_id = 'plexnode'
|
|
else:
|
|
plex_id = api.getRatingKey()
|
|
kodi_id = None
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
plexdb_item = plex_db.getItem_byId(plex_id)
|
|
try:
|
|
kodi_id = plexdb_item[0]
|
|
except TypeError:
|
|
LOG.info('Couldnt find item %s in Kodi db',
|
|
api.getRatingKey())
|
|
playqueue = PQ.get_playqueue_from_type(typus)
|
|
with PQ.LOCK:
|
|
result = PlaybackUtils(xml, playqueue).play(
|
|
plex_id,
|
|
kodi_id=kodi_id,
|
|
plex_lib_UUID=xml.attrib.get('librarySectionUUID'))
|
|
if directplay:
|
|
if result.listitem:
|
|
listitem = convert_PKC_to_listitem(result.listitem)
|
|
Player().play(listitem.getfilename(), listitem)
|
|
return Playback_Successful()
|
|
else:
|
|
return result
|
|
|
|
def triage(self, item):
|
|
_, params = item.split('?', 1)
|
|
params = dict(parse_qsl(params))
|
|
mode = params.get('mode')
|
|
LOG.debug('Received mode: %s, params: %s', mode, params)
|
|
if mode == 'play':
|
|
result = playback.playback_triage(plex_id=params.get('plex_id'),
|
|
plex_type=params.get('plex_type'),
|
|
path=params.get('path'))
|
|
elif mode == 'companion':
|
|
result = self.process_companion()
|
|
elif mode == 'plex_node':
|
|
result = self.process_plex_node(
|
|
params.get('key'),
|
|
params.get('view_offset'),
|
|
directplay=True if params.get('play_directly') else False,
|
|
node=False if params.get('node') == 'false' else True)
|
|
elif mode == 'context_menu':
|
|
ContextMenu()
|
|
result = Playback_Successful()
|
|
# Let default.py know!
|
|
# pickle_me(result)
|
|
|
|
def run(self):
|
|
queue = state.COMMAND_PIPELINE_QUEUE
|
|
LOG.info("----===## Starting Playback_Starter ##===----")
|
|
while True:
|
|
item = queue.get()
|
|
if item is None:
|
|
# Need to shutdown - initiated by command_pipeline
|
|
break
|
|
else:
|
|
self.triage(item)
|
|
queue.task_done()
|
|
LOG.info("----===## Playback_Starter stopped ##===----")
|