PlexKodiConnect/resources/lib/playback.py

436 lines
16 KiB
Python
Raw Normal View History

2018-01-08 03:50:30 +11:00
"""
Used to kick off Kodi playback
"""
2018-01-11 06:14:05 +11:00
from logging import getLogger
2018-01-21 23:42:22 +11:00
from threading import Thread
2018-01-11 06:14:05 +11:00
from xbmc import Player, sleep
2018-01-11 06:14:05 +11:00
2018-01-08 03:50:30 +11:00
from PlexAPI import API
2018-01-11 06:14:05 +11:00
from PlexFunctions import GetPlexMetadata, init_plex_playqueue
2018-01-29 03:21:28 +11:00
from downloadutils import DownloadUtils as DU
2018-01-11 06:14:05 +11:00
import plexdb_functions as plexdb
2018-02-08 00:32:58 +11:00
import kodidb_functions as kodidb
2018-01-11 06:14:05 +11:00
import playlist_func as PL
2018-01-08 03:50:30 +11:00
import playqueue as PQ
from playutils import PlayUtils
2018-01-11 06:14:05 +11:00
from PKC_listitem import PKC_ListItem
from pickler import pickle_me, Playback_Successful
import json_rpc as js
2018-02-11 22:59:04 +11:00
from utils import settings, dialog, language as lang, try_encode
2018-01-21 23:42:22 +11:00
from plexbmchelper.subscribers import LOCKER
2018-01-11 06:14:05 +11:00
import variables as v
import state
###############################################################################
LOG = getLogger("PLEX." + __name__)
# Do we need to return ultimately with a setResolvedUrl?
RESOLVE = True
2018-01-11 06:14:05 +11:00
###############################################################################
@LOCKER.lockthis
2018-01-26 03:15:38 +11:00
def playback_triage(plex_id=None, plex_type=None, path=None, resolve=True):
2018-01-08 03:50:30 +11:00
"""
2018-01-11 06:14:05 +11:00
Hit this function for addon path playback, Plex trailers, etc.
Will setup playback first, then on second call complete playback.
2018-01-08 03:50:30 +11:00
2018-01-21 23:42:22 +11:00
Will set Playback_Successful() with potentially a PKC_ListItem() attached
(to be consumed by setResolvedURL in default.py)
If trailers or additional (movie-)parts are added, default.py is released
and a completely new player instance is called with a new playlist. This
circumvents most issues with Kodi & playqueues
2018-01-26 03:15:38 +11:00
Set resolve to False if you do not want setResolvedUrl to be called on
the first pass - e.g. if you're calling this function from the original
service.py Python instance
2018-01-11 06:14:05 +11:00
"""
LOG.info('playback_triage called with plex_id %s, plex_type %s, path %s',
plex_id, plex_type, path)
global RESOLVE
RESOLVE = resolve
2018-01-11 06:14:05 +11:00
if not state.AUTHENTICATED:
LOG.error('Not yet authenticated for PMS, abort starting playback')
# "Unauthorized for PMS"
dialog('notification', lang(29999), lang(30017))
_ensure_resolve(abort=True)
2018-01-21 23:42:22 +11:00
return
2018-01-11 06:14:05 +11:00
playqueue = PQ.get_playqueue_from_type(
v.KODI_PLAYLIST_TYPE_FROM_PLEX_TYPE[plex_type])
pos = js.get_position(playqueue.playlistid)
2018-01-21 23:42:22 +11:00
# Can return -1 (as in "no playlist")
2018-01-11 06:14:05 +11:00
pos = pos if pos != -1 else 0
2018-02-03 23:54:39 +11:00
LOG.debug('playQueue position: %s for %s', pos, playqueue)
2018-01-11 06:14:05 +11:00
# Have we already initiated playback?
try:
item = playqueue.items[pos]
2018-01-11 06:14:05 +11:00
except IndexError:
initiate = True
else:
initiate = True if item.plex_id != plex_id else False
if initiate:
_playback_init(plex_id, plex_type, playqueue, pos)
2018-01-11 06:14:05 +11:00
else:
# kick off playback on second pass
_conclude_playback(playqueue, pos)
2018-01-11 06:14:05 +11:00
def _playback_init(plex_id, plex_type, playqueue, pos):
2018-01-11 06:14:05 +11:00
"""
2018-01-21 23:42:22 +11:00
Playback setup if Kodi starts playing an item for the first time.
2018-01-08 03:50:30 +11:00
"""
2018-01-21 23:42:22 +11:00
LOG.info('Initializing PKC playback')
2018-01-11 06:14:05 +11:00
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)
# "Play error"
2018-01-21 23:42:22 +11:00
dialog('notification', lang(29999), lang(30128), icon='{error}')
_ensure_resolve(abort=True)
2018-01-11 06:14:05 +11:00
return
if playqueue.kodi_pl.size() > 1:
# Special case - we already got a filled Kodi playqueue
try:
_init_existing_kodi_playlist(playqueue)
except PL.PlaylistError:
LOG.error('Aborting playback_init for longer Kodi playlist')
_ensure_resolve(abort=True)
return
# Now we need to use setResolvedUrl for the item at position pos
_conclude_playback(playqueue, pos)
return
# "Usual" case - consider trailers and parts and build both Kodi and Plex
# playqueues
2018-02-23 23:23:49 +11:00
# Fail the item we're trying to play now so we can restart the player
_ensure_resolve()
trailers = False
if (plex_type == v.PLEX_TYPE_MOVIE and not state.RESUME_PLAYBACK and
2018-01-08 03:50:30 +11:00
settings('enableCinema') == "true"):
if settings('askCinema') == "true":
2018-01-11 06:14:05 +11:00
# "Play trailers?"
trailers = dialog('yesno', lang(29999), lang(33016))
2018-01-08 03:50:30 +11:00
trailers = True if trailers else False
else:
trailers = True
2018-02-07 06:16:02 +11:00
LOG.debug('Playing trailers: %s', trailers)
2018-01-11 06:14:05 +11:00
playqueue.clear()
2018-02-07 06:12:44 +11:00
if plex_type != v.PLEX_TYPE_CLIP:
# Post to the PMS to create a playqueue - in any case due to Companion
xml = init_plex_playqueue(plex_id,
xml.attrib.get('librarySectionUUID'),
mediatype=plex_type,
trailers=trailers)
if xml is None:
LOG.error('Could not get a playqueue xml for plex id %s, UUID %s',
plex_id, xml.attrib.get('librarySectionUUID'))
# "Play error"
dialog('notification', lang(29999), lang(30128), icon='{error}')
_ensure_resolve(abort=True)
2018-02-07 06:12:44 +11:00
return
# Should already be empty, but just in case
PL.get_playlist_details_from_xml(playqueue, xml)
2018-01-11 06:14:05 +11:00
stack = _prep_playlist_stack(xml)
# Sleep a bit to let setResolvedUrl do its thing - bit ugly
sleep(200)
_process_stack(playqueue, stack)
2018-02-03 22:45:48 +11:00
# Reset some playback variables
state.CONTEXT_MENU_PLAY = False
state.FORCE_TRANSCODE = False
# Do NOT set offset, because Kodi player will return here to resolveURL
# New thread to release this one sooner (e.g. harddisk spinning up)
thread = Thread(target=threaded_playback,
args=(playqueue.kodi_pl, pos, None))
thread.setDaemon(True)
LOG.info('Done initializing playback, starting Kodi player at pos %s',
pos)
# By design, PKC will start Kodi playback using Player().play(). Kodi
# caches paths like our plugin://pkc. If we use Player().play() between
# 2 consecutive startups of exactly the same Kodi library item, Kodi's
# cache will have been flushed for some reason. Hence the 2nd call for
# plugin://pkc will be lost; Kodi will try to startup playback for an empty
# path: log entry is "CGUIWindowVideoBase::OnPlayMedia <missing path>"
thread.start()
2018-01-08 03:50:30 +11:00
def _ensure_resolve(abort=False):
"""
Will check whether RESOLVE=True and if so, fail Kodi playback startup
with the path 'PKC_Dummy_Path_Which_Fails' using setResolvedUrl (and some
pickling)
This way we're making sure that other Python instances (calling default.py)
will be destroyed.
"""
if RESOLVE:
state.PKC_CAUSED_STOP = True
result = Playback_Successful()
result.listitem = PKC_ListItem(path='PKC_Dummy_Path_Which_Fails')
pickle_me(result)
if abort:
# Reset some playback variables
state.CONTEXT_MENU_PLAY = False
state.FORCE_TRANSCODE = False
state.RESUMABLE = False
state.RESUME_PLAYBACK = False
def _init_existing_kodi_playlist(playqueue):
"""
Will take the playqueue's kodi_pl with MORE than 1 element and initiate
playback (without adding trailers)
"""
LOG.debug('Kodi playlist size: %s', playqueue.kodi_pl.size())
for i, kodi_item in enumerate(js.playlist_get_items(playqueue.playlistid)):
if i == 0:
item = PL.init_Plex_playlist(playqueue, kodi_item=kodi_item)
else:
item = PL.add_item_to_PMS_playlist(playqueue,
i,
kodi_item=kodi_item)
item.force_transcode = state.FORCE_TRANSCODE
LOG.debug('Done building Plex playlist from Kodi playlist')
2018-01-11 06:14:05 +11:00
def _prep_playlist_stack(xml):
stack = []
for item in xml:
api = API(item)
2018-02-04 00:04:17 +11:00
if (state.CONTEXT_MENU_PLAY is False and
2018-02-12 00:42:49 +11:00
api.plex_type() != v.PLEX_TYPE_CLIP):
2018-02-03 22:45:48 +11:00
# If user chose to play via PMS or force transcode, do not
# use the item path stored in the Kodi DB
2018-01-21 23:42:22 +11:00
with plexdb.Get_Plex_DB() as plex_db:
2018-02-12 00:42:49 +11:00
plex_dbitem = plex_db.getItem_byId(api.plex_id())
2018-01-21 23:42:22 +11:00
kodi_id = plex_dbitem[0] if plex_dbitem else None
kodi_type = plex_dbitem[4] if plex_dbitem else None
else:
# We will never store clips (trailers) in the Kodi DB.
# Also set kodi_id to None for playback via PMS, so that we're
# using add-on paths.
2018-01-11 06:14:05 +11:00
kodi_id = None
kodi_type = None
2018-01-21 23:42:22 +11:00
for part, _ in enumerate(item[0]):
2018-02-12 00:42:49 +11:00
api.set_part_number(part)
2018-01-21 23:42:22 +11:00
if kodi_id is None:
2018-01-11 06:14:05 +11:00
# Need to redirect again to PKC to conclude playback
path = ('plugin://%s/?plex_id=%s&plex_type=%s&mode=play'
% (v.ADDON_TYPE[api.plex_type()],
api.plex_id(),
api.plex_type()))
2018-02-12 00:42:49 +11:00
listitem = api.create_listitem()
2018-02-11 22:59:04 +11:00
listitem.setPath(try_encode(path))
2018-01-21 23:42:22 +11:00
else:
# Will add directly via the Kodi DB
path = None
listitem = None
2018-01-11 06:14:05 +11:00
stack.append({
'kodi_id': kodi_id,
'kodi_type': kodi_type,
'file': path,
'xml_video_element': item,
'listitem': listitem,
2018-01-22 04:31:49 +11:00
'part': part,
2018-02-12 00:42:49 +11:00
'playcount': api.viewcount(),
'offset': api.resume_point(),
'id': api.item_id()
2018-01-11 06:14:05 +11:00
})
return stack
def _process_stack(playqueue, stack):
2018-01-11 06:14:05 +11:00
"""
Takes our stack and adds the items to the PKC and Kodi playqueues.
"""
2018-01-21 23:42:22 +11:00
# getposition() can return -1
pos = max(playqueue.kodi_pl.getposition(), 0) + 1
for item in stack:
if item['kodi_id'] is None:
2018-01-11 06:14:05 +11:00
playlist_item = PL.add_listitem_to_Kodi_playlist(
playqueue,
2018-01-21 23:42:22 +11:00
pos,
2018-01-11 06:14:05 +11:00
item['listitem'],
file=item['file'],
xml_video_element=item['xml_video_element'])
2018-01-21 23:42:22 +11:00
else:
# Directly add element so we have full metadata
playlist_item = PL.add_item_to_kodi_playlist(
playqueue,
pos,
kodi_id=item['kodi_id'],
kodi_type=item['kodi_type'],
xml_video_element=item['xml_video_element'])
2018-01-22 04:31:49 +11:00
playlist_item.playcount = item['playcount']
playlist_item.offset = item['offset']
2018-01-21 23:42:22 +11:00
playlist_item.part = item['part']
playlist_item.id = item['id']
2018-02-03 22:45:48 +11:00
playlist_item.force_transcode = state.FORCE_TRANSCODE
2018-01-21 23:42:22 +11:00
pos += 1
2018-01-11 06:14:05 +11:00
def _conclude_playback(playqueue, pos):
2018-01-08 03:50:30 +11:00
"""
ONLY if actually being played (e.g. at 5th position of a playqueue).
Decide on direct play, direct stream, transcoding
path to
direct paths: file itself
PMS URL
Web URL
audiostream (e.g. let user choose)
subtitle stream (e.g. let user choose)
Init Kodi Playback (depending on situation):
start playback
return PKC listitem attached to result
"""
2018-01-22 21:20:37 +11:00
LOG.info('Concluding playback for playqueue position %s', pos)
2018-01-08 03:50:30 +11:00
result = Playback_Successful()
listitem = PKC_ListItem()
item = playqueue.items[pos]
2018-01-11 06:14:05 +11:00
if item.xml is not None:
# Got a Plex element
api = API(item.xml)
2018-02-12 00:42:49 +11:00
api.set_part_number(item.part)
api.create_listitem(listitem)
2018-01-08 03:50:30 +11:00
playutils = PlayUtils(api, item)
playurl = playutils.getPlayUrl()
2018-01-11 06:14:05 +11:00
else:
playurl = item.file
2018-02-11 22:59:04 +11:00
listitem.setPath(try_encode(playurl))
if item.playmethod == 'DirectStream':
2018-02-12 00:42:49 +11:00
listitem.setSubtitles(api.cache_external_subs())
elif item.playmethod == 'Transcode':
2018-01-08 03:50:30 +11:00
playutils.audio_subtitle_prefs(listitem)
2018-01-22 21:20:37 +11:00
if state.RESUME_PLAYBACK is True:
state.RESUME_PLAYBACK = False
2018-02-08 00:32:58 +11:00
if (item.offset is None and
item.plex_type not in (v.PLEX_TYPE_SONG, v.PLEX_TYPE_CLIP)):
with plexdb.Get_Plex_DB() as plex_db:
plex_dbitem = plex_db.getItem_byId(item.plex_id)
file_id = plex_dbitem[1] if plex_dbitem else None
with kodidb.GetKodiDB('video') as kodi_db:
item.offset = kodi_db.get_resume(file_id)
2018-01-22 21:20:37 +11:00
LOG.info('Resuming playback at %s', item.offset)
listitem.setProperty('StartOffset', str(item.offset))
listitem.setProperty('resumetime', str(item.offset))
# Reset the resumable flag
state.RESUMABLE = False
2018-01-08 03:50:30 +11:00
result.listitem = listitem
2018-01-11 06:14:05 +11:00
pickle_me(result)
2018-01-22 21:20:37 +11:00
LOG.info('Done concluding playback')
def process_indirect(key, offset, resolve=True):
"""
Called e.g. for Plex "Play later" - Plex items where we need to fetch an
additional xml for the actual playurl. In the PMS metadata, indirect="1" is
set.
Will release default.py with setResolvedUrl
Set resolve to False if playback should be kicked off directly, not via
setResolvedUrl
"""
LOG.info('process_indirect called with key: %s, offset: %s', key, offset)
global RESOLVE
RESOLVE = resolve
result = Playback_Successful()
if key.startswith('http') or key.startswith('{server}'):
xml = DU().downloadUrl(key)
elif key.startswith('/system/services'):
xml = DU().downloadUrl('http://node.plexapp.com:32400%s' % key)
else:
xml = DU().downloadUrl('{server}%s' % key)
try:
xml[0].attrib
except (TypeError, IndexError, AttributeError):
LOG.error('Could not download PMS metadata')
_ensure_resolve(abort=True)
return
if offset != '0':
offset = int(v.PLEX_TO_KODI_TIMEFACTOR * float(offset))
# Todo: implement offset
api = API(xml[0])
listitem = PKC_ListItem()
2018-02-12 00:42:49 +11:00
api.create_listitem(listitem)
playqueue = PQ.get_playqueue_from_type(
2018-02-12 00:42:49 +11:00
v.KODI_PLAYLIST_TYPE_FROM_PLEX_TYPE[api.plex_type()])
playqueue.clear()
item = PL.Playlist_Item()
item.xml = xml[0]
item.offset = int(offset)
item.plex_type = v.PLEX_TYPE_CLIP
item.playmethod = 'DirectStream'
# Need to get yet another xml to get the final playback url
xml = DU().downloadUrl('http://node.plexapp.com:32400%s'
% xml[0][0][0].attrib['key'])
try:
xml[0].attrib
except (TypeError, IndexError, AttributeError):
LOG.error('Could not download last xml for playurl')
_ensure_resolve(abort=True)
return
playurl = xml[0].attrib['key']
item.file = playurl
2018-02-11 22:59:04 +11:00
listitem.setPath(try_encode(playurl))
playqueue.items.append(item)
if resolve is True:
result.listitem = listitem
pickle_me(result)
else:
thread = Thread(target=Player().play,
2018-02-11 22:59:04 +11:00
args={'item': try_encode(playurl),
2018-02-03 22:45:48 +11:00
'listitem': listitem})
thread.setDaemon(True)
LOG.info('Done initializing PKC playback, starting Kodi player')
thread.start()
2018-02-08 21:16:39 +11:00
def play_xml(playqueue, xml, offset=None, start_plex_id=None):
"""
Play all items contained in the xml passed in. Called by Plex Companion.
2018-02-08 21:16:39 +11:00
Either supply the ratingKey of the starting Plex element. Or set
playqueue.selectedItemID
"""
2018-02-08 21:16:39 +11:00
LOG.info("play_xml called with offset %s, start_plex_id %s",
offset, start_plex_id)
stack = _prep_playlist_stack(xml)
_process_stack(playqueue, stack)
LOG.debug('Playqueue after play_xml update: %s', playqueue)
2018-02-08 21:16:39 +11:00
if start_plex_id is not None:
for startpos, item in enumerate(playqueue.items):
if item.plex_id == start_plex_id:
break
else:
startpos = 0
else:
2018-02-08 21:16:39 +11:00
for startpos, item in enumerate(playqueue.items):
if item.id == playqueue.selectedItemID:
break
else:
startpos = 0
thread = Thread(target=threaded_playback,
args=(playqueue.kodi_pl, startpos, offset))
LOG.info('Done play_xml, starting Kodi player at position %s', startpos)
thread.start()
def threaded_playback(kodi_playlist, startpos, offset):
"""
Seek immediately after kicking off playback is not reliable.
"""
player = Player()
player.play(kodi_playlist, None, False, startpos)
2018-02-01 17:16:09 +11:00
if offset and offset != '0':
i = 0
while not player.isPlaying():
sleep(100)
i += 1
if i > 100:
LOG.error('Could not seek to %s', offset)
return
js.seek_to(int(offset))