309 lines
12 KiB
Python
309 lines
12 KiB
Python
import logging
|
|
import re
|
|
import threading
|
|
|
|
from xbmc import sleep
|
|
|
|
import downloadutils
|
|
from clientinfo import getXArgsDeviceInfo
|
|
from utils import window, kodi_time_to_millis
|
|
import PlexFunctions as pf
|
|
import state
|
|
import variables as v
|
|
import json_rpc as js
|
|
|
|
###############################################################################
|
|
|
|
log = logging.getLogger("PLEX."+__name__)
|
|
|
|
###############################################################################
|
|
|
|
# What is Companion controllable?
|
|
CONTROLLABLE = {
|
|
v.PLEX_TYPE_PHOTO: 'skipPrevious,skipNext,stop',
|
|
v.PLEX_TYPE_AUDIO: 'playPause,stop,volume,shuffle,repeat,seekTo,' \
|
|
'skipPrevious,skipNext,stepBack,stepForward',
|
|
v.PLEX_TYPE_VIDEO: 'playPause,stop,volume,audioStream,subtitleStream,' \
|
|
'seekTo,skipPrevious,skipNext,stepBack,stepForward'
|
|
}
|
|
|
|
class SubscriptionManager:
|
|
def __init__(self, RequestMgr, player, mgr):
|
|
self.serverlist = []
|
|
self.subscribers = {}
|
|
self.info = {}
|
|
self.lastkey = ""
|
|
self.containerKey = ""
|
|
self.ratingkey = ""
|
|
self.lastplayers = {}
|
|
self.lastinfo = {
|
|
'video': {},
|
|
'audio': {},
|
|
'picture': {}
|
|
}
|
|
self.server = ""
|
|
self.protocol = "http"
|
|
self.port = ""
|
|
self.playerprops = {}
|
|
self.doUtils = downloadutils.DownloadUtils().downloadUrl
|
|
self.xbmcplayer = player
|
|
self.playqueue = mgr.playqueue
|
|
|
|
self.RequestMgr = RequestMgr
|
|
|
|
def getServerByHost(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 {}
|
|
|
|
def msg(self, players):
|
|
log.debug('players: %s', players)
|
|
msg = v.XML_HEADER
|
|
msg += '<MediaContainer size="3" commandID="INSERTCOMMANDID"'
|
|
msg += ' machineIdentifier="%s">' % v.PKC_MACHINE_IDENTIFIER
|
|
msg += self.getTimelineXML(players.get(v.KODI_TYPE_AUDIO),
|
|
v.PLEX_TYPE_AUDIO)
|
|
msg += self.getTimelineXML(players.get(v.KODI_TYPE_PHOTO),
|
|
v.PLEX_TYPE_PHOTO)
|
|
msg += self.getTimelineXML(players.get(v.KODI_TYPE_VIDEO),
|
|
v.PLEX_TYPE_VIDEO)
|
|
msg += "\n</MediaContainer>"
|
|
log.debug('msg is: %s', msg)
|
|
return msg
|
|
|
|
def getTimelineXML(self, player, ptype):
|
|
if player is None:
|
|
status = 'stopped'
|
|
else:
|
|
playerid = player['playerid']
|
|
info = state.PLAYER_STATES[playerid]
|
|
# save this info off so the server update can use it too
|
|
# self.playerprops[playerid] = info
|
|
status = ("paused", "playing")[info['speed']]
|
|
ret = ('\n <Timeline state="%s" controllable="%s" type="%s" '
|
|
'itemType="%s"' % (status, CONTROLLABLE[ptype], ptype, ptype))
|
|
if player is None:
|
|
ret += ' />'
|
|
return ret
|
|
|
|
ret += ' time="%s"' % kodi_time_to_millis(info['time'])
|
|
ret += ' duration="%s"' % kodi_time_to_millis(info['totaltime'])
|
|
ret += ' shuffle="%s"' % ("0", "1")[info['shuffled']]
|
|
ret += ' repeat="%s"' % v.PLEX_REPEAT_FROM_KODI_REPEAT[info['repeat']]
|
|
if ptype != v.KODI_TYPE_PHOTO:
|
|
ret += ' volume="%s"' % info['volume']
|
|
ret += ' mute="%s"' % ("0", "1")[info['muted']]
|
|
pbmc_server = window('pms_server')
|
|
server = self.getServerByHost(self.server)
|
|
if pbmc_server:
|
|
(self.protocol, self.server, self.port) = pbmc_server.split(':')
|
|
self.server = self.server.replace('/', '')
|
|
if info['plex_id']:
|
|
self.lastkey = "/library/metadata/%s" % info['plex_id']
|
|
self.ratingkey = info['plex_id']
|
|
ret += ' key="/library/metadata/%s"' % info['plex_id']
|
|
ret += ' ratingKey="%s"' % info['plex_id']
|
|
# PlayQueue stuff
|
|
playqueue = self.playqueue.playqueues[playerid]
|
|
pos = info['position']
|
|
try:
|
|
ret += ' playQueueItemID="%s"' % playqueue.items[pos].ID or 'null'
|
|
self.containerKey = "/playQueues/%s" % playqueue.ID or 'null'
|
|
ret += ' playQueueID="%s"' % playqueue.ID or 'null'
|
|
ret += ' playQueueVersion="%s"' % playqueue.version or 'null'
|
|
ret += ' containerKey="%s"' % self.containerKey
|
|
ret += ' guid="%s"' % playqueue.items[pos].guid or 'null'
|
|
except IndexError:
|
|
pass
|
|
ret += ' machineIdentifier="%s"' % server.get('uuid', "")
|
|
ret += ' protocol="%s"' % server.get('protocol', 'http')
|
|
ret += ' address="%s"' % server.get('server', self.server)
|
|
ret += ' port="%s"' % server.get('port', self.port)
|
|
# Temp. token set?
|
|
if state.PLEX_TRANSIENT_TOKEN:
|
|
ret += ' token="%s"' % state.PLEX_TRANSIENT_TOKEN
|
|
elif playqueue.plex_transient_token:
|
|
ret += ' token="%s"' % playqueue.plex_transient_token
|
|
# Might need an update in the future
|
|
if ptype == 'video':
|
|
ret += ' subtitleStreamID="-1"'
|
|
ret += ' audioStreamID="-1"'
|
|
|
|
ret += '/>'
|
|
return ret
|
|
|
|
def updateCommandID(self, uuid, commandID):
|
|
if commandID and self.subscribers.get(uuid, False):
|
|
self.subscribers[uuid].commandID = int(commandID)
|
|
|
|
def notify(self, event=False):
|
|
self.cleanup()
|
|
# Don't tell anyone if we don't know a Plex ID and are still playing
|
|
# (e.g. no stop called). Used for e.g. PVR/TV without PKC usage
|
|
if (not window('plex_currently_playing_itemid')
|
|
and not self.lastplayers):
|
|
return True
|
|
players = js.get_players()
|
|
# fetch the message, subscribers or not, since the server
|
|
# will need the info anyway
|
|
msg = self.msg(players)
|
|
if self.subscribers:
|
|
with threading.RLock():
|
|
for sub in self.subscribers.values():
|
|
sub.send_update(msg, len(players) == 0)
|
|
self.notifyServer(players)
|
|
self.lastplayers = players
|
|
return True
|
|
|
|
def notifyServer(self, players):
|
|
for typus, p in players.iteritems():
|
|
info = self.playerprops[p.get('playerid')]
|
|
self._sendNotification(info, int(p['playerid']))
|
|
self.lastinfo[typus] = info
|
|
# Cross the one of the list
|
|
try:
|
|
del self.lastplayers[typus]
|
|
except KeyError:
|
|
pass
|
|
# Process the players we have left (to signal a stop)
|
|
for typus, p in self.lastplayers.iteritems():
|
|
self.lastinfo[typus]['state'] = 'stopped'
|
|
self._sendNotification(self.lastinfo[typus], int(p['playerid']))
|
|
|
|
def _sendNotification(self, info, playerid):
|
|
playqueue = self.playqueue.playqueues[playerid]
|
|
xargs = getXArgsDeviceInfo(include_token=False)
|
|
params = {
|
|
'containerKey': self.containerKey or "/library/metadata/900000",
|
|
'key': self.lastkey or "/library/metadata/900000",
|
|
'ratingKey': self.ratingkey or "900000",
|
|
'state': info['state'],
|
|
'time': info['time'],
|
|
'duration': info['duration']
|
|
}
|
|
if state.PLEX_TRANSIENT_TOKEN:
|
|
xargs['X-Plex-Token'] = state.PLEX_TRANSIENT_TOKEN
|
|
elif playqueue.plex_transient_token:
|
|
xargs['X-Plex-Token'] = playqueue.plex_transient_token
|
|
if info.get('playQueueID'):
|
|
params['containerKey'] = '/playQueues/%s' % info['playQueueID']
|
|
params['playQueueVersion'] = info['playQueueVersion']
|
|
params['playQueueItemID'] = info['playQueueItemID']
|
|
serv = self.getServerByHost(self.server)
|
|
url = '%s://%s:%s/:/timeline' % (serv.get('protocol', 'http'),
|
|
serv.get('server', 'localhost'),
|
|
serv.get('port', '32400'))
|
|
self.doUtils(url, parameters=params, headerOptions=xargs)
|
|
log.debug("Sent server notification with parameters: %s to %s"
|
|
% (params, url))
|
|
|
|
def addSubscriber(self, protocol, host, port, uuid, commandID):
|
|
sub = Subscriber(protocol,
|
|
host,
|
|
port,
|
|
uuid,
|
|
commandID,
|
|
self,
|
|
self.RequestMgr)
|
|
with threading.RLock():
|
|
self.subscribers[sub.uuid] = sub
|
|
return sub
|
|
|
|
def removeSubscriber(self, uuid):
|
|
with threading.RLock():
|
|
for sub in self.subscribers.values():
|
|
if sub.uuid == uuid or sub.host == uuid:
|
|
sub.cleanup()
|
|
del self.subscribers[sub.uuid]
|
|
|
|
def cleanup(self):
|
|
with threading.RLock():
|
|
for sub in self.subscribers.values():
|
|
if sub.age > 30:
|
|
sub.cleanup()
|
|
del self.subscribers[sub.uuid]
|
|
|
|
def getPlayerProperties(self, playerid):
|
|
# Get the playqueue
|
|
playqueue = self.playqueue.playqueues[playerid]
|
|
# get info from the player
|
|
props = state.PLAYER_STATES[playerid]
|
|
info = {
|
|
'time': kodi_time_to_millis(props['time']),
|
|
'duration': kodi_time_to_millis(props['totaltime']),
|
|
'state': ("paused", "playing")[int(props['speed'])],
|
|
'shuffle': ("0", "1")[props.get('shuffled', False)],
|
|
'repeat': v.PLEX_REPEAT_FROM_KODI_REPEAT[props.get('repeat')]
|
|
}
|
|
pos = props['position']
|
|
try:
|
|
info['playQueueItemID'] = playqueue.items[pos].ID or 'null'
|
|
info['guid'] = playqueue.items[pos].guid or 'null'
|
|
info['playQueueID'] = playqueue.ID or 'null'
|
|
info['playQueueVersion'] = playqueue.version or 'null'
|
|
info['itemType'] = playqueue.items[pos].plex_type or 'null'
|
|
except:
|
|
info['itemType'] = props.get('type') or 'null'
|
|
|
|
# get the volume from the application
|
|
info['volume'] = js.get_volume()
|
|
info['mute'] = js.get_muted()
|
|
|
|
info['plex_transient_token'] = playqueue.plex_transient_token
|
|
|
|
return info
|
|
|
|
|
|
class Subscriber:
|
|
def __init__(self, protocol, host, port, uuid, commandID,
|
|
subMgr, RequestMgr):
|
|
self.protocol = protocol or "http"
|
|
self.host = host
|
|
self.port = port or 32400
|
|
self.uuid = uuid or host
|
|
self.commandID = int(commandID) or 0
|
|
self.navlocationsent = False
|
|
self.age = 0
|
|
self.doUtils = downloadutils.DownloadUtils().downloadUrl
|
|
self.subMgr = subMgr
|
|
self.RequestMgr = RequestMgr
|
|
|
|
def __eq__(self, other):
|
|
return self.uuid == other.uuid
|
|
|
|
def tostr(self):
|
|
return "uuid=%s,commandID=%i" % (self.uuid, self.commandID)
|
|
|
|
def cleanup(self):
|
|
self.RequestMgr.closeConnection(self.protocol, self.host, self.port)
|
|
|
|
def send_update(self, msg, is_nav):
|
|
self.age += 1
|
|
if not is_nav:
|
|
self.navlocationsent = False
|
|
elif self.navlocationsent:
|
|
return True
|
|
else:
|
|
self.navlocationsent = True
|
|
msg = re.sub(r"INSERTCOMMANDID", str(self.commandID), msg)
|
|
log.debug("sending xml to subscriber %s:\n%s" % (self.tostr(), msg))
|
|
url = self.protocol + '://' + self.host + ':' + self.port \
|
|
+ "/:/timeline"
|
|
t = threading.Thread(target=self.threadedSend, args=(url, msg))
|
|
t.start()
|
|
|
|
def threadedSend(self, url, msg):
|
|
"""
|
|
Threaded POST request, because they stall due to PMS response missing
|
|
the Content-Length header :-(
|
|
"""
|
|
response = self.doUtils(url,
|
|
postBody=msg,
|
|
action_type="POST")
|
|
log.debug('response is: %s', response)
|
|
if response in [False, None, 401]:
|
|
self.subMgr.removeSubscriber(self.uuid)
|