Ejemplo n.º 1
0
    def setup_manual_server(self):
        ''' Setup manual servers
        '''
        client = self.get_client()
        client.set_credentials(get_credentials())
        manager = client.auth

        try:
            self.manual_server(manager)
        except RuntimeError:
            return

        credentials = client.get_credentials()
        save_credentials(credentials)
        window('emby.restart.bool', True)
Ejemplo n.º 2
0
    def __enter__(self):
        ''' Do everything we need before the sync
        '''
        LOG.info("-->[ fullsync ]")

        if not settings('dbSyncScreensaver.bool'):

            xbmc.executebuiltin('InhibitIdleShutdown(true)')
            self.screensaver = get_screensaver()
            set_screensaver(value="")

        self.running = True
        window('jellyfin_sync.bool', True)

        return self
Ejemplo n.º 3
0
def reset():
    ''' Reset both the jellyfin database and the kodi database.
    '''
    from views import Views
    views = Views()

    if not dialog("yesno", "{jellyfin}", translate(33074)):
        return

    window('jellyfin_should_stop.bool', True)
    count = 10

    while window('jellyfin_sync.bool'):

        LOG.info("Sync is running...")
        count -= 1

        if not count:
            dialog("ok", "{jellyfin}", translate(33085))

            return

        if xbmc.Monitor().waitForAbort(1):
            return

    reset_kodi()
    reset_jellyfin()
    views.delete_playlists()
    views.delete_nodes()

    if dialog("yesno", "{jellyfin}", translate(33086)):
        reset_artwork()

    if dialog("yesno", "{jellyfin}", translate(33087)):

        xbmcvfs.delete(os.path.join(ADDON_DATA, "settings.xml"))
        xbmcvfs.delete(os.path.join(ADDON_DATA, "data.json"))
        LOG.info("[ reset settings ]")

    if xbmcvfs.exists(os.path.join(ADDON_DATA, "sync.json")):
        xbmcvfs.delete(os.path.join(ADDON_DATA, "sync.json"))

    settings('enableMusic.bool', False)
    settings('MinimumSetup', "")
    settings('MusicRescan.bool', False)
    settings('SyncInstallRunDone.bool', False)
    dialog("ok", "{jellyfin}", translate(33088))
    xbmc.executebuiltin('RestartApp')
Ejemplo n.º 4
0
    def service(self):
        ''' Keeps the service monitor going.
            Exit on Kodi shutdown or profile switch.

            if profile switch happens more than once, 
            Threads depending on abortRequest will not trigger.
        '''
        self.monitor = monitor.Monitor()
        player = self.monitor.player
        self.connect = connect.Connect()
        self.start_default()

        self.settings['mode'] = settings('useDirectPaths')

        while self.running:
            if window('emby_online.bool'):

                if self.settings['profile'] != window('emby_kodiProfile'):
                    LOG.info("[ profile switch ] %s", self.settings['profile'])

                    break

                if player.isPlaying() and player.is_playing_file(
                        player.get_playing_file()):
                    difference = datetime.today(
                    ) - self.settings['last_progress']

                    if difference.seconds > 10:
                        self.settings['last_progress'] = datetime.today()

                        update = (datetime.today() -
                                  self.settings['last_progress_report']
                                  ).seconds > 250
                        event('ReportProgressRequested', {'Report': update})

                        if update:
                            self.settings[
                                'last_progress_report'] = datetime.today()

            if window('emby.restart.bool'):
                window('emby.restart', clear=True)

                raise Exception('RestartService')

            if self.waitForAbort(1):
                break

        self.shutdown()
Ejemplo n.º 5
0
    def get_user(self, client):
        ''' Save user info.
        '''
        self.user = client['api'].get_user()
        self.config = client['api'].get_system_info()

        settings('username', self.user['Name'])
        settings('SeasonSpecials.bool',
                 self.config.get('DisplaySpecialsWithinSeasons', True))

        if 'PrimaryImageTag' in self.user:
            window(
                'EmbyUserImage',
                api.API(self.user,
                        client['auth/server-address']).get_user_artwork(
                            self.user['Id']))
Ejemplo n.º 6
0
    def run(self):

        with self.lock:
            with self.database as kodidb:
                with Database('emby') as embydb:

                    while True:

                        try:
                            item = self.queue.get(timeout=1)
                        except Queue.Empty:
                            break

                        obj = MEDIA[item['Type']](self.args[0], embydb, kodidb,
                                                  self.args[1])['Remove']

                        try:
                            obj(item['Id'])
                        except LibraryException as error:
                            if error.status == 'StopCalled':
                                break
                        except Exception as error:
                            LOG.exception(error)

                        self.queue.task_done()

                        if window('emby_should_stop.bool'):
                            break

        LOG.info("--<[ q:removed/%s ]", id(self))
        self.is_done = True
Ejemplo n.º 7
0
    def run(self):

        with self.lock, self.database as kodidb, Database('jellyfin') as jellyfindb:
            while True:

                try:
                    item = self.queue.get(timeout=1)
                except Queue.Empty:
                    break

                if item['Type'] == 'Movie':
                    obj = Movies(self.args[0], jellyfindb, kodidb, self.args[1]).remove
                elif item['Type'] in ['Series', 'Season', 'Episode']:
                    obj = TVShows(self.args[0], jellyfindb, kodidb, self.args[1]).remove
                elif item['Type'] in ['MusicAlbum', 'MusicArtist', 'AlbumArtist', 'Audio']:
                    obj = Music(self.args[0], jellyfindb, kodidb, self.args[1]).remove
                elif item['Type'] == 'MusicVideo':
                    obj = MusicVideos(self.args[0], jellyfindb, kodidb, self.args[1]).remove

                try:
                    obj(item['Id'])
                except LibraryException as error:
                    if error.status == 'StopCalled':
                        break
                except Exception as error:
                    LOG.exception(error)

                self.queue.task_done()

                if window('jellyfin_should_stop.bool'):
                    break

        LOG.info("--<[ q:removed/%s ]", id(self))
        self.is_done = True
Ejemplo n.º 8
0
    def run(self):

        with Database('jellyfin') as jellyfindb:
            database = jellyfin_db.JellyfinDatabase(jellyfindb.cursor)

            while True:

                try:
                    item_id = self.queue.get(timeout=1)
                except Queue.Empty:
                    break

                try:
                    media = database.get_media_by_id(item_id)
                    self.output[media].put({'Id': item_id, 'Type': media})
                except Exception as error:
                    LOG.exception(error)

                    items = database.get_media_by_parent_id(item_id)

                    if not items:
                        LOG.info("Could not find media %s in the jellyfin database.", item_id)
                    else:
                        for item in items:
                            self.output[item[1]].put({'Id': item[0], 'Type': item[1]})

                self.queue.task_done()

                if window('jellyfin_should_stop.bool'):
                    break

        LOG.info("--<[ q:sort/%s ]", id(self))
        self.is_done = True
Ejemplo n.º 9
0
    def report_playback(self, report=True):
        ''' Report playback progress to emby server.
            Check if the user seek.
        '''
        current_file = self.get_playing_file()

        if not self.is_playing_file(current_file):
            return

        item = self.get_file_info(current_file)

        if window('emby.external.bool'):
            return

        if not report:

            previous = item['CurrentPosition']
            item['CurrentPosition'] = int(self.getTime())

            if int(item['CurrentPosition']) == 1:
                return

            try:
                played = float(item['CurrentPosition'] * 10000000) / int(
                    item['Runtime']) * 100
            except ZeroDivisionError:  # Runtime is 0.
                played = 0

            if played > 2.0 and not self.up_next:

                self.up_next = True
                self.next_up()

            if (item['CurrentPosition'] - previous) < 30:

                return

        result = JSONRPC('Application.GetProperties').execute(
            {'properties': ["volume", "muted"]})
        result = result.get('result', {})
        item['Volume'] = result.get('volume')
        item['Muted'] = result.get('muted')
        item['CurrentPosition'] = int(self.getTime())
        self.detect_audio_subs(item)

        data = {
            'QueueableMediaTypes': "Video,Audio",
            'CanSeek': True,
            'ItemId': item['Id'],
            'MediaSourceId': item['MediaSourceId'],
            'PlayMethod': item['PlayMethod'],
            'VolumeLevel': item['Volume'],
            'PositionTicks': int(item['CurrentPosition'] * 10000000),
            'IsPaused': item['Paused'],
            'IsMuted': item['Muted'],
            'PlaySessionId': item['PlaySessionId'],
            'AudioStreamIndex': item['AudioStreamIndex'],
            'SubtitleStreamIndex': item['SubtitleStreamIndex']
        }
        item['Server']['api'].session_progress(data)
Ejemplo n.º 10
0
    def run(self):

        with self.lock:
            with self.database as kodidb:
                with Database('emby') as embydb:

                    while True:

                        try:
                            item = self.queue.get(timeout=1)
                        except Queue.Empty:
                            break

                        obj = MEDIA[item['Type']](self.args[0], embydb, kodidb,
                                                  self.args[1])[item['Type']]

                        try:
                            if obj(item) and self.notify:
                                self.notify_output.put(
                                    (item['Type'], api.API(item).get_naming()))
                        except LibraryException as error:
                            if error.status == 'StopCalled':
                                break
                        except Exception as error:
                            LOG.exception(error)

                        self.queue.task_done()

                        if window('emby_should_stop.bool'):
                            break

        LOG.info("--<[ q:updated/%s ]", id(self))
        self.is_done = True
Ejemplo n.º 11
0
    def run(self):

        while True:

            try:
                item = self.queue.get(timeout=3)
            except Queue.Empty:
                break

            time = self.music_time if item[0] == 'Audio' else self.video_time

            if time and (
                    not self.player.isPlayingVideo()
                    or xbmc.getCondVisibility('VideoPlayer.Content(livetv)')):
                dialog("notification",
                       heading="%s %s" % (_(33049), item[0]),
                       message=item[1],
                       icon="{emby}",
                       time=time,
                       sound=False)

            self.queue.task_done()

            if window('emby_should_stop.bool'):
                break

        LOG.info("--<[ q:notify/%s ]", id(self))
        self.is_done = True
Ejemplo n.º 12
0
def add_user():

    ''' Add or remove users from the default server session.
    '''
    if not window('jellyfin_online.bool'):
        return

    session = TheVoid('GetSession', {}).get()
    users = TheVoid('GetUsers', {'IsDisabled': False, 'IsHidden': False}).get()
    current = session[0]['AdditionalUsers']

    result = dialog("select", translate(33061), [translate(33062), translate(33063)] if current else [translate(33062)])

    if result < 0:
        return

    if not result:  # Add user
        eligible = [x for x in users if x['Id'] not in [current_user['UserId'] for current_user in current]]
        resp = dialog("select", translate(33064), [x['Name'] for x in eligible])

        if resp < 0:
            return

        user = eligible[resp]
        event('AddUser', {'Id': user['Id'], 'Add': True})
    else:  # Remove user
        resp = dialog("select", translate(33064), [x['UserName'] for x in current])

        if resp < 0:
            return

        user = current[resp]
        event('AddUser', {'Id': user['UserId'], 'Add': False})
Ejemplo n.º 13
0
    def run(self):

        with self.lock, self.database as kodidb, Database('jellyfin') as jellyfindb:
            while True:

                try:
                    item = self.queue.get(timeout=1)
                except Queue.Empty:
                    break

                obj = MEDIA[item['Type']](self.args[0], jellyfindb, kodidb, self.args[1]).userdata

                try:
                    obj(item)
                except LibraryException as error:
                    if error.status == 'StopCalled':
                        break
                except Exception as error:
                    LOG.exception(error)

                self.queue.task_done()

                if window('jellyfin_should_stop.bool'):
                    break

        LOG.info("--<[ q:userdata/%s ]", id(self))
        self.is_done = True
Ejemplo n.º 14
0
    def run(self):
        import objects
        ''' Workaround for playing folders only (context menu on a series/season folder > play)
            Due to plugin paths being returned within the strm, the entries are mislabelled.
            Queue items after the first item was setup and started playing via plugin above.
        '''
        xbmc.sleep(200)  # Let Kodi catch up
        LOG.info("-->[ folder play ]")
        play = None
        position = 1  # play folder should always create a new playlist.

        while True:
            if not window('emby.playlist.plugin.bool'
                          ):  # default.py wait for initial item to start up
                try:
                    try:
                        params = self.server.queue.get(timeout=0.01)
                    except Queue.Empty:
                        break

                    server = params.get('server')

                    if not server and not window('emby_online.bool'):
                        dialog("notification",
                               heading="{emby}",
                               message=_(33146),
                               icon=xbmcgui.NOTIFICATION_ERROR)

                        raise Exception("NotConnected")

                    play = objects.PlayStrm(params, server)
                    position = play.play_folder(position)

                except Exception as error:
                    LOG.exception(error)

                    xbmc.Player().stop()  # mute failed playback pop up
                    xbmc.PlayList(xbmc.PLAYLIST_VIDEO).clear()
                    self.server.queue.queue.clear()

                    break

                self.server.queue.task_done()

        self.server.threads.remove(self)
        self.server.pending = []
        LOG.info("--<[ folder play ]")
Ejemplo n.º 15
0
    def stop(self):

        window('emby.playlist.play', clear=True)
        window('emby.playlist.ready', clear=True)
        window('emby.playlist.start', clear=True)
        window('emby.playlist.audio', clear=True)

        self.server.threads.remove(self)
        self.server.pending = []
        LOG.info("--<[ queue play ]")
Ejemplo n.º 16
0
    def run(self):
        with self.lock, self.database as kodidb, Database(
                'jellyfin') as jellyfindb:
            while True:

                try:
                    item = self.queue.get(timeout=1)
                except Queue.Empty:
                    break

                if item['Type'] == 'Movie':
                    obj = Movies(self.args[0], jellyfindb, kodidb,
                                 self.args[1]).movie
                elif item['Type'] == 'Boxset':
                    obj = Movies(self.args[0], jellyfindb, kodidb,
                                 self.args[1]).boxset
                elif item['Type'] == 'Series':
                    obj = TVShows(self.args[0], jellyfindb, kodidb,
                                  self.args[1]).tvshow
                elif item['Type'] == 'Season':
                    obj = TVShows(self.args[0], jellyfindb, kodidb,
                                  self.args[1]).season
                elif item['Type'] == 'Episode':
                    obj = TVShows(self.args[0], jellyfindb, kodidb,
                                  self.args[1]).episode
                elif item['Type'] == 'MusicVideo':
                    obj = MusicVideos(self.args[0], jellyfindb, kodidb,
                                      self.args[1]).musicvideo
                elif item['Type'] == 'MusicAlbum':
                    obj = Music(self.args[0], jellyfindb, kodidb,
                                self.args[1]).album
                elif item['Type'] == 'MusicArtist':
                    obj = Music(self.args[0], jellyfindb, kodidb,
                                self.args[1]).artist
                elif item['Type'] == 'AlbumArtist':
                    obj = Music(self.args[0], jellyfindb, kodidb,
                                self.args[1]).albumartist
                elif item['Type'] == 'Audio':
                    obj = Music(self.args[0], jellyfindb, kodidb,
                                self.args[1]).song

                try:
                    if obj(item) and self.notify:
                        self.notify_output.put(
                            (item['Type'], api.API(item).get_naming()))
                except LibraryException as error:
                    if error.status == 'StopCalled':
                        break
                except Exception as error:
                    LOG.exception(error)

                self.queue.task_done()

                if window('jellyfin_should_stop.bool'):
                    break

        LOG.info("--<[ q:updated/%s ]", id(self))
        self.is_done = True
Ejemplo n.º 17
0
    def onSettingsChanged(self):
        ''' React to setting changes that impact window values.
        '''
        if window('jellyfin_should_stop.bool'):
            return

        if settings('logLevel') != self.settings['log_level']:

            log_level = settings('logLevel')
            self.settings['logLevel'] = log_level
            LOG.info("New log level: %s", log_level)

        if settings('enableContext.bool') != self.settings['enable_context']:

            window('jellyfin_context', settings('enableContext'))
            self.settings['enable_context'] = settings('enableContext.bool')
            LOG.info("New context setting: %s",
                     self.settings['enable_context'])

        if settings('enableContextTranscode.bool'
                    ) != self.settings['enable_context_transcode']:

            window('jellyfin_context_transcode',
                   settings('enableContextTranscode'))
            self.settings['enable_context_transcode'] = settings(
                'enableContextTranscode.bool')
            LOG.info("New context transcode setting: %s",
                     self.settings['enable_context_transcode'])

        if settings('useDirectPaths'
                    ) != self.settings['mode'] and self.library_thread.started:

            self.settings['mode'] = settings('useDirectPaths')
            LOG.info("New playback mode setting: %s", self.settings['mode'])

            if not self.settings.get('mode_warn'):

                self.settings['mode_warn'] = True
                dialog("yesno", "{jellyfin}", translate(33118))

        if settings('kodiCompanion.bool') != self.settings['kodi_companion']:
            self.settings['kodi_companion'] = settings('kodiCompanion.bool')

            if not self.settings['kodi_companion']:
                dialog("ok", "{jellyfin}", translate(33138))
Ejemplo n.º 18
0
    def window_single_node(self, index, item_type, view):
        ''' Single destination node.
        '''
        path = "library://video/jellyfin_%s.xml" % view['Tag'].replace(" ", "")
        window_path = "ActivateWindow(Videos,%s,return)" % path

        window_prop = "Jellyfin.nodes.%s" % index
        window('%s.title' % window_prop, view['Name'])
        window('%s.path' % window_prop, window_path)
        window('%s.content' % window_prop, path)
        window('%s.type' % window_prop, item_type)
Ejemplo n.º 19
0
    def __exit__(self, exc_type, exc_val, exc_tb):
        ''' Exiting sync
        '''
        self.running = False
        window('emby_sync', clear=True)

        if self.screensaver is not None:

            xbmc.executebuiltin('InhibitIdleShutdown(false)')
            set_screensaver(value=self.screensaver)
            self.screensaver = None

        if self.artwork is not None:

            settings('enableTextureCache.bool', True)
            self.artwork = None
            LOG.info("[ enable artwork cache ]")

        LOG.info("--<[ fullsync ]")
Ejemplo n.º 20
0
    def StopServer(self, server, data, *args, **kwargs):

        if not data['ServerId']:
            window('emby.server.state', clear=True)
        else:
            window('emby.server.%s.state' % data['ServerId'], clear=True)
            current = window('emby.server.states.json')
            current.pop(current.index(data['ServerId']))
            window('emby.server.states.json', current)
Ejemplo n.º 21
0
    def run(self):
        count = 0

        with requests.Session() as s:
            while True:

                try:
                    item_ids = self.queue.get(timeout=1)
                except Queue.Empty:

                    LOG.info("--<[ q:download/%s/%s ]", id(self), count)
                    LOG.info("--[ q:download/remove ] %s", self.removed)

                    break

                clean_list = [str(x) for x in item_ids]
                request = {
                    'type': "GET",
                    'handler': "Users/{UserId}/Items",
                    'params': {
                        'Ids': ','.join(clean_list),
                        'Fields': api.info()
                    }
                }
                try:
                    result = self.server['http/request'](request, s)
                    self.removed.extend(
                        list(
                            set(clean_list) -
                            set([str(x['Id']) for x in result['Items']])))

                    for item in result['Items']:

                        if item['Type'] in self.output:
                            self.output[item['Type']].put(item)
                except HTTPException as error:
                    LOG.error("--[ http status: %s ]", error.status)

                    if error.status in ('ServerUnreachable', 'ReadTimeout',
                                        503):
                        self.queue.put(item_ids)

                        break

                except Exception as error:
                    LOG.exception(error)

                count += len(clean_list)
                self.queue.task_done()

                if window('emby_should_stop.bool'):
                    break

            self.is_done = True
Ejemplo n.º 22
0
    def get(self):

        while True:

            response = window('jellyfin_%s.json' % self.data['VoidName'])

            if response != "":

                LOG.debug("--<[ nostromo/jellyfin_%s.json ]", self.data['VoidName'])
                window('jellyfin_%s' % self.data['VoidName'], clear=True)

                return response

            if window('jellyfin_should_stop.bool'):
                LOG.info("Abandon mission! A black hole just swallowed [ %s/%s ]", self.method, self.data['VoidName'])

                return

            xbmc.sleep(100)
            LOG.info("--[ void/%s ]", self.data['VoidName'])
Ejemplo n.º 23
0
    def window_clear(self, name=None):
        ''' Clearing window prop setup for Views.
        '''
        total = int(window((name or 'Jellyfin.nodes') + '.total') or 0)
        props = [
            "index", "id", "path", "artwork", "title", "content", "type"
            "inprogress.content", "inprogress.title", "inprogress.content",
            "inprogress.path", "nextepisodes.title", "nextepisodes.content",
            "nextepisodes.path", "unwatched.title", "unwatched.content",
            "unwatched.path", "recent.title", "recent.content", "recent.path",
            "recentepisodes.title", "recentepisodes.content",
            "recentepisodes.path", "inprogressepisodes.title",
            "inprogressepisodes.content", "inprogressepisodes.path"
        ]
        for i in range(total):
            for prop in props:
                window('Jellyfin.nodes.%s.%s' % (str(i), prop), clear=True)

        for prop in props:
            window('Jellyfin.nodes.%s' % prop, clear=True)
Ejemplo n.º 24
0
    def set_playlist(self,
                     item,
                     listitem,
                     db_id=None,
                     transcode=False,
                     *args,
                     **kwargs):
        ''' Verify seektime, set intros, set main item and set additional parts.
            Detect the seektime for video type content.
            Verify the default video action set in Kodi for accurate resume behavior.
        '''
        seektime = window('emby.resume.bool')
        window('emby.resume', clear=True)

        if item['MediaType'] in ('Video', 'Audio'):
            resume = item['UserData'].get('PlaybackPositionTicks')

            if resume:
                if get_play_action() == "Resume":
                    seektime = True

                if transcode and not seektime:
                    choice = self.resume_dialog(
                        api.API(item, self.server).adjust_resume(
                            (resume or 0) / 10000000.0))

                    if choice is None:
                        raise Exception("User backed out of resume dialog.")

                    seektime = False if not choice else True

        if settings('enableCinema.bool') and not seektime:
            self._set_intros(item)

        self.set_listitem(item, listitem, db_id, seektime)
        playutils.set_properties(item, item['PlaybackInfo']['Method'],
                                 self.server_id)
        self.stack.append([item['PlaybackInfo']['Path'], listitem])

        if item.get('PartCount'):
            self._set_additional_parts(item['Id'])
Ejemplo n.º 25
0
    def on_notification(self, sender, method, data):

        LOG.debug("[ %s: %s ] %s", sender, method, json.dumps(data))
        data['MonitorMethod'] = method

        if self.sleep:
            LOG.info("System.OnSleep detected, ignore monitor request.")

            return

        if method == 'Playlist.OnClear' and data[
                'playlistid'] == self.playlistid:  # set in webservice.py
            window('emby.play.widget', clear=True)

        server = self._get_server(method, data)
        self.queue.put((
            getattr(self, method.replace('.', '_')),
            server,
            data,
        ))
        self.add_worker()
Ejemplo n.º 26
0
    def __enter__(self):
        ''' Open the connection and return the Database class.
            This is to allow for the cursor, conn and others to be accessible.
        '''
        self.path = self._sql(self.db_file)
        self.conn = sqlite3.connect(self.path, timeout=self.timeout)
        self.cursor = self.conn.cursor()

        if self.db_file in ('video', 'music', 'texture', 'emby'):
            self.conn.execute("PRAGMA journal_mode=WAL"
                              )  # to avoid writing conflict with kodi

        LOG.debug("--->[ database: %s ] %s", self.db_file, id(self.conn))

        if not window('emby_db_check.bool') and self.db_file == 'emby':

            window('emby_db_check.bool', True)
            emby_tables(self.cursor)
            self.conn.commit()

        return self
Ejemplo n.º 27
0
    def run(self):
        import objects
        ''' Workaround for widgets only playback.
            Widgets start with a music playlist, this causes bugs in skin, etc.
            Create a new video playlist for the item and play it.
        '''
        xbmc.sleep(200)  # Let Kodi catch up
        LOG.info("-->[ widget play ]")
        play = None

        xbmc.PlayList(xbmc.PLAYLIST_MUSIC).clear()
        xbmc.PlayList(xbmc.PLAYLIST_VIDEO).clear()
        objects.utils.enable_busy_dialog()

        try:
            server = self.params.get('server')

            if not server and not window('emby_online.bool'):
                dialog("notification",
                       heading="{emby}",
                       message=_(33146),
                       icon=xbmcgui.NOTIFICATION_ERROR)

                raise Exception("NotConnected")

            play = objects.PlayStrm(self.params, server)
            play.play()

        except Exception as error:
            LOG.exception(error)
            objects.utils.disable_busy_dialog()
            xbmc.Player().stop()  # mute failed playback pop up
            xbmc.PlayList(xbmc.PLAYLIST_VIDEO).clear()
        else:
            objects.utils.disable_busy_dialog()
            window('emby.play.widget.bool', True)
            play.start_playback()

        self.server.pending = []
        LOG.info("--<[ widget play ]")
Ejemplo n.º 28
0
    def _set_intros(self, item):
        ''' if we have any play them when the movie/show is not being resumed.
        '''
        intros = TheVoid('GetIntros', {
            'ServerId': self.server_id,
            'Id': item['Id']
        }).get()

        if intros['Items']:
            enabled = True

            if settings('askCinema') == "true":

                resp = dialog("yesno",
                              heading="{jellyfin}",
                              line1=translate(33016))
                if not resp:

                    enabled = False
                    LOG.info("Skip trailers.")

            if enabled:
                for intro in intros['Items']:

                    listitem = xbmcgui.ListItem()
                    LOG.info("[ intro/%s ] %s", intro['Id'], intro['Name'])

                    play = playutils.PlayUtils(intro, False, self.server_id,
                                               self.server)
                    source = play.select_source(play.get_sources())
                    self.set_listitem(intro, listitem, intro=True)
                    listitem.setPath(intro['PlaybackInfo']['Path'])
                    playutils.set_properties(intro,
                                             intro['PlaybackInfo']['Method'],
                                             self.server_id)

                    self.stack.append(
                        [intro['PlaybackInfo']['Path'], listitem])

                window('jellyfin.skip.%s' % intro['Id'], value="true")
def on_update(data, server):
    ''' Only for manually marking as watched/unwatched
    '''
    try:
        kodi_id = data['item']['id']
        media = data['item']['type']
        playcount = int(data['playcount'])
        LOG.info(" [ update/%s ] kodi_id: %s media: %s", playcount, kodi_id,
                 media)
    except (KeyError, TypeError):
        LOG.debug("Invalid playstate update")

        return

    item = database.get_item(kodi_id, media)

    if item:

        if not window('jellyfin.skip.%s.bool' % item[0]):
            server.jellyfin.item_played(item[0], playcount)

        window('jellyfin.skip.%s' % item[0], clear=True)
Ejemplo n.º 30
0
    def __enter__(self):
        ''' Do everything we need before the sync
        '''
        LOG.info("-->[ fullsync ]")

        if not settings('dbSyncScreensaver.bool'):

            xbmc.executebuiltin('InhibitIdleShutdown(true)')
            self.screensaver = get_screensaver()
            set_screensaver(value="")

        self.running = True

        if settings('enableTextureCache.bool') and settings('lowPowered.bool'):

            self.artwork = True
            settings('enableTextureCache.bool', False)
            LOG.info("[ disable artwork cache ]")

        window('emby_sync.bool', True)

        return self