Big update

resources/lib/app/playstate.py

@@ -63,3 +63,6 @@ class PlayState(object):
         self.context_menu_play = False
         # Which Kodi player is/has been active? (either int 1, 2 or 3)
         self.active_players = set()
+        # Have we initiated playback via Plex Companion or Alexa - so from the
+        # Plex side of things?
+        self.initiated_by_plex = False

resources/lib/kodimonitor.py

@@ -322,12 +322,10 @@ class KodiMonitor(xbmc.Monitor):
         LOG.debug('Current Kodi playlist: %s', kodi_playlist)
         kodi_item = PL.playlist_item_from_kodi(kodi_playlist[position])
         if isinstance(self.playqueue.items[0], PL.PlaylistItemDummy):
-            # Get rid of the very first element in the queue that Kodi marked
-            # as unplayed (the one to init the queue)
-            LOG.debug('Deleting the very first playqueue item')
-            js.playlist_remove(self.playqueue.playlistid, 0)
-            del self.playqueue.items[0]
-            position = 0
+            # This dummy item will be deleted by webservice soon - it won't
+            # play
+            LOG.debug('Dummy item detected')
+            position = 1
         elif kodi_item != self.playqueue.items[position]:
             LOG.debug('Different playqueue items: %s vs. %s ',
                       kodi_item, self.playqueue.items[position])
@@ -487,9 +485,6 @@ def _record_playstate(status, ended):
         playcount += 1
         time = 0
     with kodi_db.KodiVideoDB() as kodidb:
-        LOG.error('Setting file_id %s, time %s, totaltime %s, playcount %s, '
-                  'last_played %s',
-                  db_item['kodi_fileid'], time, totaltime, playcount, last_played)
         kodidb.set_resume(db_item['kodi_fileid'],
                           time,
                           totaltime,

resources/lib/playlist_func.py

@@ -5,8 +5,7 @@ Collection of functions associated with Kodi and Plex playlists and playqueues
 """
 from __future__ import absolute_import, division, unicode_literals
 from logging import getLogger
-
-import xbmc
+import threading
 
 from .plex_api import API
 from .plex_db import PlexDB
@@ -139,20 +138,59 @@ class PlayQueue(object):
         self.force_transcode = None
         LOG.debug('Playlist cleared: %s', self)
 
-    def init(self, plex_id, plex_type=None, position=None, synched=True,
-             force_transcode=None):
+    def play(self, plex_id, plex_type=None, startpos=None, position=None,
+             synched=True, force_transcode=None):
         """
         Initializes the playQueue with e.g. trailers and additional file parts
         Pass synched=False if you're sure that this item has not been synched
         to Kodi
+
+        Or resolves webservice paths to actual paths
+        """
+        LOG.debug('Play called with plex_id %s, plex_type %s, position %s, '
+                  'synched %s, force_transcode %s, startpos %s', plex_id,
+                  plex_type, position, synched, force_transcode, startpos)
+        resolve = False
+        try:
+            if plex_id == self.items[startpos].plex_id:
+                resolve = True
+        except IndexError:
+            pass
+        if resolve:
+            LOG.info('Resolving playback')
+            self._resolve(plex_id, startpos)
+        else:
+            LOG.info('Initializing playback')
+            self.init(plex_id,
+                      plex_type,
+                      startpos,
+                      position,
+                      synched,
+                      force_transcode)
+
+    def _resolve(self, plex_id, startpos):
+        """
+        The Plex playqueue has already been initialized. We resolve the path
+        from original webservice http://127.0.0.1 to the "correct" Plex one
+        """
+        self.index = startpos + 1
+        xml = PF.GetPlexMetadata(plex_id)
+        if xml in (None, 401):
+            raise PlaylistError('Could not get Plex metadata %s for %s',
+                                plex_id, self.items[startpos])
+        api = API(xml[0])
+        resume = self._resume_playback(None, xml[0])
+        self._kodi_add_xml(xml[0], api, resume)
+        # Add additional file parts, if any exist
+        self._add_additional_parts(xml)
+
+    def init(self, plex_id, plex_type=None, startpos=None, position=None,
+             synched=True, force_transcode=None):
+        """
+        Initializes the Plex and PKC playqueue for playback
         """
-        LOG.error('Current Kodi playlist: %s',
-                  js.playlist_get_items(self.playlistid))
-        LOG.debug('Initializing with plex_id %s, plex_type %s, position %s, '
-                  'synched %s, force_transcode %s, index %s', plex_id,
-                  plex_type, position, synched, force_transcode, self.index)
         self.index = position
-        if self.kodi_pl.size() != len(self.items):
+        while len(self.items) < self.kodi_pl.size():
             # The original item that Kodi put into the playlist, e.g.
             # {
             #     u'title': u'',
@@ -161,13 +199,10 @@ class PlayQueue(object):
             #     u'label': u''
             # }
             # We CANNOT delete that item right now - so let's add a dummy
-            # on the PKC side
-            LOG.debug('Detected Kodi playlist size %s to be off for PKC: %s',
-                      self.kodi_pl.size(), len(self.items))
-            while len(self.items) < self.kodi_pl.size():
+            # on the PKC side to keep all indicees lined up.
+            # The failing item will be deleted in webservice.py
             LOG.debug('Adding a dummy item to our playqueue')
-                playlistitem = PlaylistItemDummy()
-                self.items.insert(0, playlistitem)
+            self.items.insert(0, PlaylistItemDummy())
         self.force_transcode = force_transcode
         if synched:
             with PlexDB(lock=False) as plexdb:
@@ -316,7 +351,11 @@ class PlayQueue(object):
             raise PlaylistError('Position %s too large for playlist length %s'
                                 % (pos, len(self.items)))
         LOG.debug('Adding item to Kodi playlist at position %s: %s', pos, item)
-        if item.kodi_id is not None and item.kodi_type is not None:
+        if listitem:
+            self.kodi_pl.add(url=listitem.getPath(),
+                             listitem=listitem,
+                             index=pos)
+        elif item.kodi_id is not None and item.kodi_type is not None:
             # This method ensures we have full Kodi metadata, potentially
             # with more artwork, for example, than Plex provides
             if pos == len(self.items):
@@ -330,24 +369,24 @@ class PlayQueue(object):
                 raise PlaylistError('Kodi did not add item to playlist: %s',
                                     answ)
         else:
-            if not listitem:
             if item.xml is None:
                 LOG.debug('Need to get metadata for item %s', item)
                 item.xml = PF.GetPlexMetadata(item.plex_id)
                 if item.xml in (None, 401):
                     raise PlaylistError('Could not get metadata for %s', item)
+            api = API(item.xml[0])
             listitem = widgets.get_listitem(item.xml, 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.plex_type
+                'plex_id': item.plex_id,
+                'plex_type': api.plex_type()
             }
             if item.force_transcode:
                 args['transcode'] = 'true'
             url = utils.extend_url(url, args)
             item.file = url
             listitem.setPath(url.encode('utf-8'))
-            self.kodi_pl.add(url=listitem.getPath(),
+            self.kodi_pl.add(url=url.encode('utf-8'),
                              listitem=listitem,
                              index=pos)
 
@@ -372,9 +411,6 @@ class PlayQueue(object):
         except (TypeError, AttributeError, KeyError, IndexError):
             raise PlaylistError('Could not add item %s to playlist %s'
                                 % (item, self))
-        if len(xml) != len(self.items) + 1:
-            raise PlaylistError('Could not add item %s to playlist %s - wrong'
-                                ' length received' % (item, self))
         for actual_pos, xml_video_element in enumerate(xml):
             api = API(xml_video_element)
             if api.plex_id() == item.plex_id:
@@ -395,7 +431,7 @@ class PlayQueue(object):
         LOG.debug('Removing position %s on the Kodi side for %s', pos, self)
         answ = js.playlist_remove(self.playlistid, pos)
         if 'error' in answ:
-            raise PlaylistError('Could not remove item: %s' % answ)
+            raise PlaylistError('Could not remove item: %s' % answ['error'])
 
     def plex_move_item(self, before, after):
         """
@@ -436,9 +472,71 @@ class PlayQueue(object):
         self.items.insert(after, self.items.pop(before))
         LOG.debug('Done moving items for %s', self)
 
-    def start_playback(self, pos=0):
-        LOG.info('Starting playback at %s for %s', pos, self)
-        xbmc.Player().play(self.kodi_pl, startpos=pos, windowed=False)
+    def init_from_xml(self, xml, offset=None, start_plex_id=None, repeat=None,
+                      transient_token=None):
+        """
+        Play all items contained in the xml passed in. Called by Plex Companion.
+        Either supply the ratingKey of the starting Plex element. Or set
+        playqueue.selectedItemID
+
+            offset [float]: will seek to position offset after playback start
+            start_plex_id [int]: the plex_id of the element that should be
+                played
+            repeat [int]: 0: don't repear
+                          1: repeat item
+                          2: repeat everything
+            transient_token [unicode]: temporary token received from the PMS
+
+        Will stop current playback and start playback at the end
+        """
+        LOG.debug("init_from_xml called with offset %s, start_plex_id %s",
+                  offset, start_plex_id)
+        app.APP.player.stop()
+        self.clear()
+        self.update_details_from_xml(xml)
+        self.repeat = 0 if not repeat else repeat
+        self.plex_transient_token = transient_token
+        for pos, xml_video_element in enumerate(xml):
+            playlistitem = PlaylistItem(xml_video_element=xml_video_element)
+            self.kodi_add_item(playlistitem, pos)
+            self.items.append(playlistitem)
+        # Where do we start playback?
+        if start_plex_id is not None:
+            for startpos, item in enumerate(self.items):
+                if item.plex_id == start_plex_id:
+                    break
+            else:
+                startpos = 0
+        else:
+            for startpos, item in enumerate(self.items):
+                if item.id == self.selectedItemID:
+                    break
+            else:
+                startpos = 0
+        self.start_playback(pos=startpos, offset=offset)
+
+    def start_playback(self, pos=0, offset=0):
+        """
+        Seek immediately after kicking off playback is not reliable.
+        Threaded, since we need to return BEFORE seeking
+        """
+        LOG.info('Starting playback at %s offset %s for %s', pos, offset, self)
+        thread = threading.Thread(target=self._threaded_playback,
+                                  args=(self.kodi_pl, pos, offset))
+        thread.start()
+
+    @staticmethod
+    def _threaded_playback(kodi_playlist, pos, offset):
+        app.APP.player.play(kodi_playlist, startpos=pos, windowed=False)
+        if offset:
+            i = 0
+            while not app.APP.is_playing:
+                app.APP.monitor.waitForAbort(0.1)
+                i += 1
+                if i > 50:
+                    LOG.warn('Could not seek to %s', offset)
+                    return
+            js.seek_to(offset)
 
 
 class PlaylistItem(object):
@@ -1069,7 +1167,7 @@ def move_playlist_item(playlist, before_pos, after_pos):
     LOG.debug('Done moving for %s', playlist)
 
 
-def get_PMS_playlist(playlist, playlist_id=None):
+def get_PMS_playlist(playlist=None, playlist_id=None):
     """
     Fetches the PMS playlist/playqueue as an XML. Pass in playlist_id if we
     need to fetch a new playlist
@@ -1077,7 +1175,7 @@ def get_PMS_playlist(playlist, playlist_id=None):
     Returns None if something went wrong
     """
     playlist_id = playlist_id if playlist_id else playlist.id
-    if playlist.kind == 'playList':
+    if playlist and playlist.kind == 'playList':
         xml = DU().downloadUrl("{server}/playlists/%s/items" % playlist_id)
     else:
         xml = DU().downloadUrl("{server}/playQueues/%s" % playlist_id)

resources/lib/plex_companion.py

@@ -15,7 +15,6 @@ from .plex_api import API
 from . import utils
 from . import plex_functions as PF
 from . import playlist_func as PL
-from . import playback
 from . import json_rpc as js
 from . import playqueue as PQ
 from . import variables as v
@@ -40,6 +39,8 @@ def update_playqueue_from_PMS(playqueue,
 
     repeat = 0, 1, 2
     offset = time offset in Plextime (milliseconds)
+
+    Will (re)start playback
     """
     LOG.info('New playqueue %s received from Plex companion with offset '
              '%s, repeat %s', playqueue_id, offset, repeat)
@@ -47,21 +48,15 @@ def update_playqueue_from_PMS(playqueue,
     if transient_token is None:
         transient_token = playqueue.plex_transient_token
     with app.APP.lock_playqueues:
-        xml = PL.get_PMS_playlist(playqueue, playqueue_id)
-        try:
-            xml.attrib
-        except AttributeError:
+        xml = PL.get_PMS_playlist(playlist_id=playqueue_id)
+        if xml is None:
             LOG.error('Could now download playqueue %s', playqueue_id)
-            return
-        playqueue.clear()
-        try:
-            PL.get_playlist_details_from_xml(playqueue, xml)
-        except PL.PlaylistError:
-            LOG.error('Could not get playqueue ID %s', playqueue_id)
-            return
-        playqueue.repeat = 0 if not repeat else int(repeat)
-        playqueue.plex_transient_token = transient_token
-        playback.play_xml(playqueue, xml, offset)
+            raise PL.PlaylistError()
+        app.PLAYSTATE.initiated_by_plex = True
+        playqueue.init_from_xml(xml,
+                                offset=offset,
+                                repeat=0 if not repeat else int(repeat),
+                                transient_token=transient_token)
 
 
 class PlexCompanion(backgroundthread.KillableThread):
@@ -81,45 +76,48 @@ class PlexCompanion(backgroundthread.KillableThread):
 
     @staticmethod
     def _process_alexa(data):
+        app.PLAYSTATE.initiated_by_plex = True
         xml = PF.GetPlexMetadata(data['key'])
         try:
             xml[0].attrib
         except (AttributeError, IndexError, TypeError):
             LOG.error('Could not download Plex metadata for: %s', data)
-            return
+            raise PL.PlaylistError()
         api = API(xml[0])
         if api.plex_type() == v.PLEX_TYPE_ALBUM:
             LOG.debug('Plex music album detected')
-            PQ.init_playqueue_from_plex_children(
-                api.plex_id(),
+            xml = PF.GetAllPlexChildren(api.plex_id())
+            try:
+                xml[0].attrib
+            except (TypeError, IndexError, AttributeError):
+                LOG.error('Could not download the album xml for %s', data)
+                raise PL.PlaylistError()
+            playqueue = PQ.get_playqueue_from_type('audio')
+            playqueue.init_from_xml(xml,
                                     transient_token=data.get('token'))
         elif data['containerKey'].startswith('/playQueues/'):
             _, container_key, _ = PF.ParseContainerKey(data['containerKey'])
             xml = PF.DownloadChunks('{server}/playQueues/%s' % container_key)
             if xml is None:
-                # "Play error"
-                utils.dialog('notification',
-                             utils.lang(29999),
-                             utils.lang(30128),
-                             icon='{error}')
-                return
+                LOG.error('Could not get playqueue for %s', data)
+                raise PL.PlaylistError()
             playqueue = PQ.get_playqueue_from_type(
                 v.KODI_PLAYLIST_TYPE_FROM_PLEX_TYPE[api.plex_type()])
-            playqueue.clear()
-            PL.get_playlist_details_from_xml(playqueue, xml)
-            playqueue.plex_transient_token = data.get('token')
-            if data.get('offset') != '0':
+            if data.get('offset') not in ('0', None):
                 offset = float(data['offset']) / 1000.0
             else:
                 offset = None
-            playback.play_xml(playqueue, xml, offset)
+            playqueue.init_from_xml(xml,
+                                    offset=offset,
+                                    transient_token=data.get('token'))
         else:
             app.CONN.plex_transient_token = data.get('token')
-            if data.get('offset') != '0':
+            if data.get('offset') not in (None, '0'):
                 app.PLAYSTATE.resume_playback = True
-            playback.playback_triage(api.plex_id(),
-                                     api.plex_type(),
-                                     resolve=False)
+            path = ('http://127.0.0.1:%s/plex/play/file.strm?plex_id=%s'
+                    % (v.WEBSERVICE_PORT, api.plex_id()))
+            path += '&plex_type=%s' % api.plex_type()
+            executebuiltin(('PlayMedia(%s)' % path).encode('utf-8'))
 
     @staticmethod
     def _process_node(data):
@@ -150,7 +148,7 @@ class PlexCompanion(backgroundthread.KillableThread):
                 xml[0].attrib
             except (AttributeError, IndexError, TypeError):
                 LOG.error('Could not download Plex metadata')
-                return
+                raise PL.PlaylistError()
             api = API(xml[0])
             playqueue = PQ.get_playqueue_from_type(
                 v.KODI_PLAYLIST_TYPE_FROM_PLEX_TYPE[api.plex_type()])
@@ -167,6 +165,7 @@ class PlexCompanion(backgroundthread.KillableThread):
         """
         playqueue = PQ.get_playqueue_from_type(
             v.KODI_PLAYLIST_TYPE_FROM_PLEX_TYPE[data['type']])
+        try:
             pos = js.get_position(playqueue.playlistid)
             if 'audioStreamID' in data:
                 index = playqueue.items[pos].kodi_stream_index(
@@ -181,6 +180,8 @@ class PlexCompanion(backgroundthread.KillableThread):
                     app.APP.player.setSubtitleStream(index)
             else:
                 LOG.error('Unknown setStreams command: %s', data)
+        except KeyError:
+            LOG.warn('Could not process stream data: %s', data)
 
     @staticmethod
     def _process_refresh(data):
@@ -220,6 +221,7 @@ class PlexCompanion(backgroundthread.KillableThread):
         """
         LOG.debug('Processing: %s', task)
         data = task['data']
+        try:
             if task['action'] == 'alexa':
                 with app.APP.lock_playqueues:
                     self._process_alexa(data)
@@ -233,10 +235,15 @@ class PlexCompanion(backgroundthread.KillableThread):
                 with app.APP.lock_playqueues:
                     self._process_refresh(data)
             elif task['action'] == 'setStreams':
-            try:
                 self._process_streams(data)
-            except KeyError:
-                pass
+        except PL.PlaylistError:
+            LOG.error('Could not process companion data: %s', data)
+            # "Play Error"
+            utils.dialog('notification',
+                         utils.lang(29999),
+                         utils.lang(30128),
+                         icon='{error}')
+            app.PLAYSTATE.initiated_by_plex = False
 
     def run(self):
         """

resources/lib/webservice.py

@@ -13,16 +13,16 @@ import Queue
 import xbmc
 import xbmcvfs
 
+from .plex_api import API
 from .plex_db import PlexDB
 from . import backgroundthread, utils, variables as v, app, playqueue as PQ
-from . import playlist_func as PL, json_rpc as js
+from . import playlist_func as PL, json_rpc as js, plex_functions as PF
 
 
 LOG = getLogger('PLEX.webservice')
 
 
 class WebService(backgroundthread.KillableThread):
-
     ''' Run a webservice to trigger playback.
     '''
     def is_alive(self):
@@ -48,7 +48,7 @@ class WebService(backgroundthread.KillableThread):
             conn.request('QUIT', '/')
             conn.getresponse()
         except Exception as error:
-            xbmc.log('Plex.WebService abort error: %s' % error, xbmc.LOGWARNING)
+            xbmc.log('PLEX.webservice abort error: %s' % error, xbmc.LOGWARNING)
 
     def suspend(self):
         """
@@ -124,7 +124,7 @@ class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
                 # Silence "[Errno 10054] An existing connection was forcibly
                 # closed by the remote host"
                 return
-            xbmc.log('Plex.WebService handle error: %s' % error, xbmc.LOGWARNING)
+            xbmc.log('PLEX.webservice handle error: %s' % error, xbmc.LOGWARNING)
 
     def do_QUIT(self):
         ''' send 200 OK response, and set server.stop to True
@@ -144,7 +144,12 @@ class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
         if '?' in path:
             path = path.split('?', 1)[1]
         params = dict(utils.parse_qsl(path))
+        if 'plex_id' not in params:
+            LOG.error('No plex_id received for path %s', path)
+            return
 
+        if 'plex_type' in params and params['plex_type'].lower() == 'none':
+            del params['plex_type']
         if 'plex_type' not in params:
             LOG.debug('Need to look-up plex_type')
             with PlexDB(lock=False) as plexdb:
@@ -154,9 +159,20 @@ class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
             else:
                 LOG.debug('No plex_type found, using Kodi player id')
                 players = js.get_players()
+                if players:
                     params['plex_type'] = v.PLEX_TYPE_CLIP if 'video' in players \
                         else v.PLEX_TYPE_SONG
-
+                    LOG.debug('Using the following plex_type: %s',
+                              params['plex_type'])
+                else:
+                    xml = PF.GetPlexMetadata(params['plex_id'])
+                    if xml in (None, 401):
+                        LOG.error('Could not get metadata for %s', params)
+                        return
+                    api = API(xml[0])
+                    params['plex_type'] = api.plex_type()
+                    LOG.debug('Got metadata, using plex_type %s',
+                              params['plex_type'])
         return params
 
     def do_HEAD(self):
@@ -172,7 +188,7 @@ class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
     def handle_request(self, headers_only=False):
         '''Send headers and reponse
         '''
-        xbmc.log('Plex.WebService handle_request called. headers %s, path: %s'
+        xbmc.log('PLEX.webservice handle_request called. headers %s, path: %s'
                  % (headers_only, self.path), xbmc.LOGDEBUG)
         try:
             if b'extrafanart' in self.path or b'extrathumbs' in self.path:
@@ -311,11 +327,13 @@ class QueuePlay(backgroundthread.KillableThread):
             self.synched = not params['synched'].lower() == 'false'
 
     def _get_playqueue(self):
-        if (self.plex_type in v.PLEX_VIDEOTYPES and
-                xbmc.getCondVisibility('Window.IsVisible(Home.xml)')):
+        playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_VIDEO)
+        if ((self.plex_type in v.PLEX_VIDEOTYPES and
+             not app.PLAYSTATE.initiated_by_plex and
+             xbmc.getCondVisibility('Window.IsVisible(Home.xml)'))):
             # Video launched from a widget - which starts a Kodi AUDIO playlist
             # We will empty everything and start with a fresh VIDEO playlist
-            LOG.debug('Widget video playback detected; relaunching')
+            LOG.debug('Widget video playback detected')
             video_widget_playback = True
             # Release default.py
             utils.window('plex.playlist.ready', value='true')
@@ -335,14 +353,9 @@ class QueuePlay(backgroundthread.KillableThread):
             else:
                 LOG.debug('Audio playback detected')
                 playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_AUDIO)
-            playqueue.clear(kodi=False)
         return playqueue, video_widget_playback
 
     def run(self):
-        """
-        We cannot use js.get_players() to reliably get the active player
-        Use Kodimonitor's OnNotification and OnAdd
-        """
         LOG.debug('##===---- Starting QueuePlay ----===##')
         abort = False
         play_folder = False
@@ -358,6 +371,8 @@ class QueuePlay(backgroundthread.KillableThread):
         # Position to add next element to queue - we're doing this at the end
         # of our current playqueue
         position = playqueue.kodi_pl.size()
+        # Set to start_position + 1 because first item will fail
+        utils.window('plex.playlist.start', str(start_position + 1))
         LOG.debug('start_position %s, position %s for current playqueue: %s',
                   start_position, position, playqueue)
         while True:
@@ -370,7 +385,7 @@ class QueuePlay(backgroundthread.KillableThread):
                     LOG.debug('Wrapping up')
                     if xbmc.getCondVisibility('VideoPlayer.Content(livetv)'):
                         # avoid issues with ongoing Live TV playback
-                        xbmc.Player().stop()
+                        app.APP.player.stop()
                     count = 50
                     while not utils.window('plex.playlist.ready'):
                         xbmc.sleep(50)
@@ -392,48 +407,47 @@ class QueuePlay(backgroundthread.KillableThread):
                         LOG.info('Start normal playback')
                         # Release default.py
                         utils.window('plex.playlist.play', value='true')
+                        # Remove the playlist element we just added with the
+                        # right path
+                        xbmc.sleep(1000)
+                        playqueue.kodi_remove_item(start_position)
+                        del playqueue.items[start_position]
                     LOG.debug('Done wrapping up')
                     break
                 self.load_params(params)
                 if play_folder:
-                    # position = play.play_folder(position)
-                    item = PL.PlaylistItem(plex_id=self.plex_id,
+                    playlistitem = PL.PlaylistItem(plex_id=self.plex_id,
                                                    plex_type=self.plex_type,
                                                    kodi_id=self.kodi_id,
                                                    kodi_type=self.kodi_type)
-                    item.force_transcode = self.force_transcode
-                    playqueue.add_item(item, position)
+                    playlistitem.force_transcode = self.force_transcode
+                    playqueue.add_item(playlistitem, position)
                     position += 1
                 else:
                     if self.server.pending.count(params['plex_id']) != len(self.server.pending):
+                        # E.g. when selecting "play" for an entire video genre
                         LOG.debug('Folder playback detected')
                         play_folder = True
-                    # Set to start_position + 1 because first item will fail
-                    utils.window('plex.playlist.start', str(start_position + 1))
-                    playqueue.init(self.plex_id,
+                        xbmc.executebuiltin('Activateutils.window(busydialognocancel)')
+                    playqueue.play(self.plex_id,
                                    plex_type=self.plex_type,
+                                   startpos=start_position,
                                    position=position,
                                    synched=self.synched,
                                    force_transcode=self.force_transcode)
                     # Do NOT start playback here - because Kodi already started
                     # it!
-                    # playqueue.start_playback(position)
                     position = playqueue.index
-                    if play_folder:
-                        xbmc.executebuiltin('Activateutils.window(busydialognocancel)')
-            except PL.PlaylistError as error:
-                abort = True
-                LOG.warn('Not playing due to the following: %s', error)
             except Exception:
                 abort = True
-                utils.ERROR()
+                utils.ERROR(notify=True)
             try:
                 self.server.queue.task_done()
             except ValueError:
-                # "task_done() called too many times"
+                # "task_done() called too many times" when aborting
                 pass
             if abort:
-                xbmc.Player().stop()
+                app.APP.player.stop()
                 playqueue.clear()
                 self.server.queue.queue.clear()
                 if play_folder:
@@ -444,6 +458,7 @@ class QueuePlay(backgroundthread.KillableThread):
 
         utils.window('plex.playlist.ready', clear=True)
         utils.window('plex.playlist.start', clear=True)
+        app.PLAYSTATE.initiated_by_plex = False
         self.server.threads.remove(self)
         self.server.pending = []
         LOG.debug('##===---- QueuePlay Stopped ----===##')