PlexKodiConnect/resources/lib/plexbmchelper/subscribers.py

505 lines
19 KiB
Python
Raw Normal View History

#!/usr/bin/env python
# -*- coding: utf-8 -*-
2017-12-14 06:14:27 +11:00
"""
Manages getting playstate from Kodi and sending it to the PMS as well as
subscribed Plex Companion clients.
"""
from __future__ import absolute_import, division, unicode_literals
2017-12-14 06:14:27 +11:00
from logging import getLogger
2018-06-22 03:24:37 +10:00
from threading import Thread
2017-12-09 23:47:19 +11:00
2018-06-22 03:24:37 +10:00
from ..downloadutils import DownloadUtils as DU
from .. import timing
2018-11-19 00:59:17 +11:00
from .. import app
2018-06-22 03:24:37 +10:00
from .. import variables as v
from .. import json_rpc as js
from .. import playqueue as PQ
2016-01-15 22:12:52 +11:00
2016-09-03 01:20:19 +10:00
###############################################################################
2018-06-22 03:24:37 +10:00
LOG = getLogger('PLEX.subscribers')
2016-09-03 01:20:19 +10:00
###############################################################################
2017-12-10 03:23:50 +11:00
# What is Companion controllable?
CONTROLLABLE = {
2018-01-01 23:28:39 +11:00
v.PLEX_PLAYLIST_TYPE_VIDEO: 'playPause,stop,volume,shuffle,audioStream,'
'subtitleStream,seekTo,skipPrevious,skipNext,'
'stepBack,stepForward',
v.PLEX_PLAYLIST_TYPE_AUDIO: 'playPause,stop,volume,shuffle,repeat,seekTo,'
'skipPrevious,skipNext,stepBack,stepForward',
2018-01-02 23:28:25 +11:00
v.PLEX_PLAYLIST_TYPE_PHOTO: 'playPause,stop,skipPrevious,skipNext'
2017-12-10 03:23:50 +11:00
}
STREAM_DETAILS = {
'video': 'currentvideostream',
'audio': 'currentaudiostream',
'subtitle': 'currentsubtitle'
}
2018-01-01 23:28:39 +11:00
XML = ('%s<MediaContainer commandID="{command_id}" location="{location}">\n'
' <Timeline {%s}/>\n'
' <Timeline {%s}/>\n'
' <Timeline {%s}/>\n'
'</MediaContainer>\n') % (v.XML_HEADER,
v.PLEX_PLAYLIST_TYPE_VIDEO,
v.PLEX_PLAYLIST_TYPE_AUDIO,
v.PLEX_PLAYLIST_TYPE_PHOTO)
# Headers are different for Plex Companion - use these for PMS notifications
HEADERS_PMS = {
2018-01-02 23:28:25 +11:00
'Connection': 'keep-alive',
'Accept': 'text/plain, */*; q=0.01',
'Accept-Language': 'en',
2018-01-02 23:28:25 +11:00
'Accept-Encoding': 'gzip, deflate',
'User-Agent': '%s %s (%s)' % (v.ADDON_NAME, v.ADDON_VERSION, v.DEVICE)
}
2018-01-01 23:28:39 +11:00
def params_pms():
2018-01-02 04:36:28 +11:00
"""
Returns the url parameters for communicating with the PMS
2018-01-02 04:36:28 +11:00
"""
return {
'X-Plex-Client-Identifier': v.PKC_MACHINE_IDENTIFIER,
'X-Plex-Device': v.DEVICE,
'X-Plex-Device-Name': v.DEVICENAME,
'X-Plex-Model': v.MODEL,
'X-Plex-Platform': v.PLATFORM,
'X-Plex-Platform-Version': v.PLATFORM_VERSION,
'X-Plex-Product': v.ADDON_NAME,
'X-Plex-Version': v.ADDON_VERSION,
2018-01-02 04:36:28 +11:00
}
def headers_companion_client():
"""
Headers are different for Plex Companion - use these for a Plex Companion
client
"""
return {
2018-01-02 22:13:41 +11:00
'Content-Type': 'application/xml',
2018-01-02 04:36:28 +11:00
'Connection': 'Keep-Alive',
'X-Plex-Client-Identifier': v.PKC_MACHINE_IDENTIFIER,
'X-Plex-Device-Name': v.DEVICENAME,
'X-Plex-Platform': v.PLATFORM,
'X-Plex-Platform-Version': v.PLATFORM_VERSION,
'X-Plex-Product': v.ADDON_NAME,
'X-Plex-Version': v.ADDON_VERSION,
2018-01-02 04:36:28 +11:00
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': 'en,*'
}
2018-01-01 23:28:39 +11:00
def update_player_info(playerid):
"""
Updates all player info for playerid [int] in state.py.
"""
2018-11-23 18:42:29 +11:00
app.PLAYSTATE.player_states[playerid].update(js.get_player_props(playerid))
app.PLAYSTATE.player_states[playerid]['volume'] = js.get_volume()
app.PLAYSTATE.player_states[playerid]['muted'] = js.get_muted()
2018-01-01 23:28:39 +11:00
2017-12-14 18:29:38 +11:00
class SubscriptionMgr(object):
2017-12-14 06:14:27 +11:00
"""
Manages Plex companion subscriptions
"""
def __init__(self, request_mgr, player):
self.serverlist = []
2016-01-15 22:12:52 +11:00
self.subscribers = {}
self.info = {}
self.server = ""
self.protocol = "http"
self.port = ""
self.isplaying = False
self.location = 'navigation'
2017-12-14 06:14:27 +11:00
# In order to be able to signal a stop at the end
self.last_params = {}
self.lastplayers = {}
2018-02-05 01:36:30 +11:00
# In order to signal a stop to Plex Web ONCE on playback stop
self.stop_sent_to_web = True
2017-12-14 18:29:38 +11:00
self.request_mgr = request_mgr
2017-12-14 18:29:38 +11:00
def _server_by_host(self, host):
if len(self.serverlist) == 1:
return self.serverlist[0]
for server in self.serverlist:
if (server.get('serverName') in host or
server.get('server') in host):
return server
return {}
@staticmethod
def _get_correct_position(info, playqueue):
"""
Kodi tells us the PLAYLIST position, not PLAYQUEUE position, if the
user initiated playback of a playlist
"""
if playqueue.kodi_playlist_playback:
position = 0
else:
position = info['position'] or 0
return position
def msg(self, players):
"""
Returns a timeline xml as str
(xml containing video, audio, photo player state)
"""
self.isplaying = False
self.location = 'navigation'
2018-01-01 23:28:39 +11:00
answ = str(XML)
timelines = {
v.PLEX_PLAYLIST_TYPE_VIDEO: None,
v.PLEX_PLAYLIST_TYPE_AUDIO: None,
v.PLEX_PLAYLIST_TYPE_PHOTO: None
}
for typus in timelines:
if players.get(v.KODI_PLAYLIST_TYPE_FROM_PLEX_PLAYLIST_TYPE[typus]) is None:
timeline = {
2018-01-01 23:28:39 +11:00
'controllable': CONTROLLABLE[typus],
'type': typus,
'state': 'stopped'
}
2018-01-01 23:28:39 +11:00
else:
timeline = self._timeline_dict(players[
2018-01-02 04:36:28 +11:00
v.KODI_PLAYLIST_TYPE_FROM_PLEX_PLAYLIST_TYPE[typus]],
typus)
timelines[typus] = self._dict_to_xml(timeline)
timelines.update({'command_id': '{command_id}',
'location': self.location})
2018-01-01 23:28:39 +11:00
return answ.format(**timelines)
2017-12-21 19:28:06 +11:00
@staticmethod
2018-01-01 23:28:39 +11:00
def _dict_to_xml(dictionary):
2017-12-21 19:28:06 +11:00
"""
2018-01-01 23:28:39 +11:00
Returns the string 'key1="value1" key2="value2" ...' for dictionary
2017-12-21 19:28:06 +11:00
"""
2018-01-01 23:28:39 +11:00
answ = ''
for key, value in dictionary.iteritems():
answ += '%s="%s" ' % (key, value)
return answ
def _timeline_dict(self, player, ptype):
2018-11-19 00:59:17 +11:00
with app.APP.lock_playqueues:
playerid = player['playerid']
2018-11-19 00:59:17 +11:00
info = app.PLAYSTATE.player_states[playerid]
playqueue = PQ.PLAYQUEUES[playerid]
position = self._get_correct_position(info, playqueue)
try:
item = playqueue.items[position]
except IndexError:
# E.g. for direct path playback for single item
return {
'controllable': CONTROLLABLE[ptype],
'type': ptype,
'state': 'stopped'
}
self.isplaying = True
self.stop_sent_to_web = False
if ptype in (v.PLEX_PLAYLIST_TYPE_VIDEO,
v.PLEX_PLAYLIST_TYPE_PHOTO):
self.location = 'fullScreenVideo'
2018-11-19 00:59:17 +11:00
pbmc_server = app.CONN.server
if pbmc_server:
(self.protocol, self.server, self.port) = pbmc_server.split(':')
self.server = self.server.replace('/', '')
status = 'paused' if int(info['speed']) == 0 else 'playing'
2018-11-19 00:59:17 +11:00
duration = timing.kodi_time_to_millis(info['totaltime'])
shuffle = '1' if info['shuffled'] else '0'
mute = '1' if info['muted'] is True else '0'
answ = {
2018-01-01 23:28:39 +11:00
'controllable': CONTROLLABLE[ptype],
'protocol': self.protocol,
'address': self.server,
'port': self.port,
2018-11-26 05:46:34 +11:00
'machineIdentifier': app.CONN.machine_identifier,
'state': status,
2018-01-01 23:28:39 +11:00
'type': ptype,
'itemType': ptype,
2018-11-19 00:59:17 +11:00
'time': timing.kodi_time_to_millis(info['time']),
'duration': duration,
'seekRange': '0-%s' % duration,
'shuffle': shuffle,
'repeat': v.PLEX_REPEAT_FROM_KODI_REPEAT[info['repeat']],
'volume': info['volume'],
'mute': mute,
'mediaIndex': 0, # Still to implement from here
'partIndex': 0,
'partCount': 1,
'providerIdentifier': 'com.plexapp.plugins.library',
2018-01-01 23:28:39 +11:00
}
# Get the plex id from the PKC playqueue not info, as Kodi jumps to
# next playqueue element way BEFORE kodi monitor onplayback is
# called
if item.plex_id:
answ['key'] = '/library/metadata/%s' % item.plex_id
answ['ratingKey'] = item.plex_id
# PlayQueue stuff
if info['container_key']:
answ['containerKey'] = info['container_key']
if (info['container_key'] is not None and
info['container_key'].startswith('/playQueues')):
answ['playQueueID'] = playqueue.id
answ['playQueueVersion'] = playqueue.version
answ['playQueueItemID'] = item.id
if playqueue.items[position].guid:
answ['guid'] = item.guid
# Temp. token set?
2018-11-19 00:59:17 +11:00
if app.CONN.plex_transient_token:
answ['token'] = app.CONN.plex_transient_token
elif playqueue.plex_transient_token:
answ['token'] = playqueue.plex_transient_token
# Process audio and subtitle streams
if ptype == v.PLEX_PLAYLIST_TYPE_VIDEO:
strm_id = self._plex_stream_index(playerid, 'audio')
if strm_id:
answ['audioStreamID'] = strm_id
else:
LOG.error('We could not select a Plex audiostream')
strm_id = self._plex_stream_index(playerid, 'video')
if strm_id:
answ['videoStreamID'] = strm_id
else:
LOG.error('We could not select a Plex videostream')
if info['subtitleenabled']:
try:
strm_id = self._plex_stream_index(playerid, 'subtitle')
except KeyError:
# subtitleenabled can be True while currentsubtitle can
# still be {}
strm_id = None
if strm_id is not None:
# If None, then the subtitle is only present on Kodi
# side
answ['subtitleStreamID'] = strm_id
return answ
2018-01-01 23:28:39 +11:00
def signal_stop(self):
"""
Externally called on PKC shutdown to ensure that PKC signals a stop to
the PMS. Otherwise, PKC might be stuck at "currently playing"
"""
LOG.info('Signaling a complete stop to PMS')
# To avoid RuntimeError, don't use self.lastplayers
for playerid in (0, 1, 2):
self.last_params['state'] = 'stopped'
self._send_pms_notification(playerid,
self.last_params,
timeout=0.0001)
2018-01-01 23:28:39 +11:00
def _plex_stream_index(self, playerid, stream_type):
"""
Returns the current Plex stream index [str] for the player playerid
stream_type: 'video', 'audio', 'subtitle'
"""
playqueue = PQ.PLAYQUEUES[playerid]
2018-11-19 00:59:17 +11:00
info = app.PLAYSTATE.player_states[playerid]
position = self._get_correct_position(info, playqueue)
if info[STREAM_DETAILS[stream_type]] == -1:
kodi_stream_index = -1
else:
kodi_stream_index = info[STREAM_DETAILS[stream_type]]['index']
return playqueue.items[position].plex_stream_index(kodi_stream_index,
stream_type)
2016-02-07 22:38:50 +11:00
2017-12-14 18:29:38 +11:00
def update_command_id(self, uuid, command_id):
"""
Updates the Plex Companien client with the machine identifier uuid with
command_id
"""
2018-11-19 00:59:17 +11:00
with app.APP.lock_subscriber:
if command_id and self.subscribers.get(uuid):
self.subscribers[uuid].command_id = int(command_id)
2016-08-11 03:03:37 +10:00
def _playqueue_init_done(self, players):
"""
update_player_info() can result in values BEFORE kodi monitor is called.
Hence we'd have a missmatch between the state.PLAYER_STATES and our
playqueues.
"""
for player in players.values():
2018-11-19 00:59:17 +11:00
info = app.PLAYSTATE.player_states[player['playerid']]
playqueue = PQ.PLAYQUEUES[player['playerid']]
position = self._get_correct_position(info, playqueue)
try:
item = playqueue.items[position]
except IndexError:
# E.g. for direct path playback for single item
return False
if item.plex_id != info['plex_id']:
# Kodi playqueue already progressed; need to wait until
# everything is loaded
return False
return True
2017-12-14 18:29:38 +11:00
def notify(self):
"""
Causes PKC to tell the PMS and Plex Companion players to receive a
notification what's being played.
"""
2018-11-19 00:59:17 +11:00
with app.APP.lock_subscriber:
self._cleanup()
# Get all the active/playing Kodi players (video, audio, pictures)
players = js.get_players()
# Update the PKC info with what's playing on the Kodi side
for player in players.values():
update_player_info(player['playerid'])
# Check whether we can use the CURRENT info or whether PKC is still
# initializing
if self._playqueue_init_done(players) is False:
LOG.debug('PKC playqueue is still initializing - skip update')
return
self._notify_server(players)
if self.subscribers:
msg = self.msg(players)
for subscriber in self.subscribers.values():
subscriber.send_update(msg)
self.lastplayers = players
2016-08-11 03:03:37 +10:00
2017-12-14 18:29:38 +11:00
def _notify_server(self, players):
2017-12-14 06:14:27 +11:00
for typus, player in players.iteritems():
self._send_pms_notification(
player['playerid'], self._get_pms_params(player['playerid']))
try:
del self.lastplayers[typus]
except KeyError:
pass
# Process the players we have left (to signal a stop)
2018-01-01 23:28:39 +11:00
for player in self.lastplayers.values():
2017-12-14 06:14:27 +11:00
self.last_params['state'] = 'stopped'
self._send_pms_notification(player['playerid'], self.last_params)
2017-12-14 06:14:27 +11:00
def _get_pms_params(self, playerid):
2018-11-19 00:59:17 +11:00
info = app.PLAYSTATE.player_states[playerid]
playqueue = PQ.PLAYQUEUES[playerid]
position = self._get_correct_position(info, playqueue)
2018-01-02 04:36:28 +11:00
try:
item = playqueue.items[position]
2018-01-02 04:36:28 +11:00
except IndexError:
return self.last_params
status = 'paused' if int(info['speed']) == 0 else 'playing'
2017-12-14 06:41:29 +11:00
params = {
'state': status,
2018-01-02 04:36:28 +11:00
'ratingKey': item.plex_id,
'key': '/library/metadata/%s' % item.plex_id,
2018-11-19 00:59:17 +11:00
'time': timing.kodi_time_to_millis(info['time']),
'duration': timing.kodi_time_to_millis(info['totaltime'])
}
2018-01-01 23:28:39 +11:00
if info['container_key'] is not None:
# params['containerKey'] = info['container_key']
2018-01-01 23:28:39 +11:00
if info['container_key'].startswith('/playQueues/'):
# params['playQueueVersion'] = playqueue.version
# params['playQueueID'] = playqueue.id
2018-01-02 04:36:28 +11:00
params['playQueueItemID'] = item.id
2017-12-14 06:14:27 +11:00
self.last_params = params
return params
def _send_pms_notification(self, playerid, params, timeout=None):
"""
Pass a really low timeout in seconds if shutting down Kodi and we don't
need the PMS' response
"""
2017-12-14 18:29:38 +11:00
serv = self._server_by_host(self.server)
playqueue = PQ.PLAYQUEUES[playerid]
xargs = params_pms()
xargs.update(params)
2018-11-19 00:59:17 +11:00
if app.CONN.plex_transient_token:
xargs['X-Plex-Token'] = app.CONN.plex_transient_token
elif playqueue.plex_transient_token:
xargs['X-Plex-Token'] = playqueue.plex_transient_token
2018-11-19 00:59:17 +11:00
elif app.ACCOUNT.pms_token:
xargs['X-Plex-Token'] = app.ACCOUNT.pms_token
url = '%s://%s:%s/:/timeline' % (serv.get('protocol', 'http'),
serv.get('server', 'localhost'),
serv.get('port', '32400'))
DU().downloadUrl(url,
authenticate=False,
parameters=xargs,
headerOverride=HEADERS_PMS,
timeout=timeout)
2017-12-14 06:14:27 +11:00
LOG.debug("Sent server notification with parameters: %s to %s",
xargs, url)
2016-01-27 22:18:54 +11:00
2017-12-14 18:29:38 +11:00
def add_subscriber(self, protocol, host, port, uuid, command_id):
"""
Adds a new Plex Companion subscriber to PKC.
"""
2017-12-14 06:14:27 +11:00
subscriber = Subscriber(protocol,
host,
port,
uuid,
2017-12-14 18:29:38 +11:00
command_id,
2017-12-14 06:14:27 +11:00
self,
2017-12-14 18:29:38 +11:00
self.request_mgr)
2018-11-19 00:59:17 +11:00
with app.APP.lock_subscriber:
self.subscribers[subscriber.uuid] = subscriber
2017-12-14 06:14:27 +11:00
return subscriber
2017-12-14 18:29:38 +11:00
def remove_subscriber(self, uuid):
"""
Removes a connected Plex Companion subscriber with machine identifier
uuid from PKC notifications.
(Calls the cleanup() method of the subscriber)
"""
2018-11-19 00:59:17 +11:00
with app.APP.lock_subscriber:
for subscriber in self.subscribers.values():
if subscriber.uuid == uuid or subscriber.host == uuid:
subscriber.cleanup()
del self.subscribers[subscriber.uuid]
2017-12-14 18:29:38 +11:00
def _cleanup(self):
2017-12-21 19:28:06 +11:00
for subscriber in self.subscribers.values():
if subscriber.age > 30:
subscriber.cleanup()
del self.subscribers[subscriber.uuid]
2016-01-15 22:12:52 +11:00
2017-12-14 18:29:38 +11:00
class Subscriber(object):
"""
Plex Companion subscribing device
"""
def __init__(self, protocol, host, port, uuid, command_id, sub_mgr,
request_mgr):
2016-01-15 22:12:52 +11:00
self.protocol = protocol or "http"
self.host = host
self.port = port or 32400
self.uuid = uuid or host
2017-12-14 18:29:38 +11:00
self.command_id = int(command_id) or 0
2016-01-15 22:12:52 +11:00
self.age = 0
2017-12-14 18:29:38 +11:00
self.sub_mgr = sub_mgr
self.request_mgr = request_mgr
2016-01-15 22:12:52 +11:00
def __eq__(self, other):
return self.uuid == other.uuid
2016-01-15 22:12:52 +11:00
def cleanup(self):
2017-12-14 18:29:38 +11:00
"""
Closes the connection to the Plex Companion client
"""
self.request_mgr.closeConnection(self.protocol, self.host, self.port)
2018-01-02 20:58:28 +11:00
def send_update(self, msg):
2017-12-14 18:29:38 +11:00
"""
Sends msg to the Plex Companion client (via .../:/timeline)
"""
2016-01-15 22:12:52 +11:00
self.age += 1
2018-01-01 23:28:39 +11:00
msg = msg.format(command_id=self.command_id)
2017-12-14 06:14:27 +11:00
LOG.debug("sending xml to subscriber uuid=%s,commandID=%i:\n%s",
2017-12-14 18:29:38 +11:00
self.uuid, self.command_id, msg)
2018-01-01 23:28:39 +11:00
url = '%s://%s:%s/:/timeline' % (self.protocol, self.host, self.port)
2017-12-14 18:29:38 +11:00
thread = Thread(target=self._threaded_send, args=(url, msg))
thread.start()
2016-02-07 22:38:50 +11:00
2017-12-14 18:29:38 +11:00
def _threaded_send(self, url, msg):
"""
Threaded POST request, because they stall due to response missing
the Content-Length header :-(
"""
2018-01-02 04:36:28 +11:00
response = DU().downloadUrl(url,
action_type="POST",
postBody=msg,
authenticate=False,
headerOverride=headers_companion_client())
2017-12-14 18:29:38 +11:00
if response in (False, None, 401):
self.sub_mgr.remove_subscriber(self.uuid)