labojumi

addon.py

-import os,os.path,sys, urllib, urlparse
-from kodiswift import Plugin, ListItem, storage
-from kodiswift import xbmc, xbmcgui, xbmcplugin, xbmcvfs, xbmcaddon, CLI_MODE, SortMethod
-from resources.lib import photostation_api
+# -*- coding: utf-8 -*-
 try:
     import wingdbstub
 except:
     pass
+import os,os.path,sys, urllib, urlparse
+#import xbmc, xbmcgui, xbmcplugin, xbmcvfs, xbmcaddon
+from kodiswift import Plugin, ListItem, storage
+from kodiswift import xbmc, xbmcgui, xbmcplugin, xbmcvfs, xbmcaddon, CLI_MODE, SortMethod
+from resources.lib import photostation_api
 
 plugin = Plugin()
+handle = sys.argv[1]
 
 view_mode = plugin.get_setting("view_mode",str)
-
 server = plugin.get_setting("server", str)
 user = plugin.get_setting("user", str)
 password = plugin.get_setting("password", str)
 order = plugin.get_setting("order", str)
 video_quality = plugin.get_setting("video_quality", str)
 picture_quality = plugin.get_setting("picture_quality", str)
+thumbnail_quality = plugin.get_setting("thumbnail_quality", str)
+play_next = plugin.get_setting("play_next", bool)
+start_page = plugin.get_setting("start_page", str)
 
 ps = photostation_api.PhotoStationAPI("http://home.blue.lv/photo")
 try:
     data = plugin.request.url.replace(prefix,"")
     data = urllib.unquote(data)
     #default_oid = "album_323031372f323031372d30312d313320536c69646f73616e61"
-    default_oid = ""
+    default_oid = ""  #start_page
     if not data:
         data = default_oid
     oid = plugin.request.path[1:]
     else:
         page = int(qs["page"])
 
-    if not oid or oid.startswith("album"):
+    if not oid or oid.startswith("album") or oid.startswith("category"):
         plugin.set_content("images")
 
+        content = []
+        if not oid:
+            categories = ps.get_categories()["categories"]
+            for cat in categories:
+                if cat["hidden"]:
+                    continue
+                data2 = prefix + cat["id"]
+                label = cat["name"]
+                item = xbmcgui.ListItem(label, "", "", "", data2)
+                item.setInfo("Image", {"title":label})
+                item.setProperty("is_folder", "true")
+                item.setProperty("url", data2)
+                #items.append(item)
+                xbmcplugin.addDirectoryItem(handle=plugin.handle, url=data2, listitem=item, isFolder=True)
+
         offset = 0 if page_size == -1 else (page - 1) * page_size
         limit = -1 if page_size == -1 else page_size
-        content = ps.get_album_list(oid, offset=offset, limit=limit, sort_by=sorting, sort_direction=order )
+        if "category" in oid:
+            content = ps.get_category_list(oid)
+        else:
+            content = ps.get_album_list(oid, offset=offset, limit=limit, sort_by=sorting, sort_direction=order )
         items = []
         for f in content["items"]:
-            title = f["info"]["name"]
+            label = f["info"]["title"]
+            label2 = f["additional"]["file_location"] if "file_location" in f["additional"] else ""
             type = f["type"]
             oid2 = f["id"]
-            #is_playable = True if type in ("video","photo") else False
-            is_folder = False if type in ("video","photo") else True
-            thumb_url = ps.get_thumb_url(f["id"],"small")
+            is_playable = "true" if type in ("video","photo") else ""
+            is_folder = "" if type in ("video","photo") else "true"
+            thumb_quality = thumbnail_quality if thumbnail_quality in  f["thumbnail_status"] else "small"
+            thumb_url = ps.get_thumb_url(f["id"],thumb_quality)
+            #thumb_url = urllib.quote(thumb_url, ":/")
             data2 = prefix+f["id"]
-            #item = ListItem(title, icon=thumb_url, thumbnail=thumb_url, path=data2)
-            #item.is_folder = False if type in ("video","photo") else True
 
             if type=="album":
-                label2 = "%s photos, %s videos"%(f["additional"]["item_count"]["photo"],f["additional"]["item_count"]["video"])
-                item = xbmcgui.ListItem(title, label2, thumb_url, thumb_url, path=data2)
-                item.setInfo(
-                    "Image",
-                    {"title":f["info"]["title"],"picturepath":f["additional"]["file_location"]}
-                    )
+                nfiles = int(f["additional"]["item_count"]["photo"]) + int(f["additional"]["item_count"]["video"]) if "item_count" in f["additional"] else None
+                suf = "\n(%s)" % nfiles if nfiles else ""
+                label2 = "%s photos, %s videos"%(f["additional"]["item_count"]["photo"],f["additional"]["item_count"]["video"]) if "item_count" in f["additional"] else ""
+                label = label + suf
+                li_type = "video"  # pictures
+                tags = {
+                    #"title":f["info"]["title"],
+                    "title": label,
+                    #"picturepath":f["additional"]["file_location"]
+                    "label": label,
+                    "plotline":f["additional"]["file_location"] + "\n" + label2 if "file_location" in f["additional"] else "",
+                    "plot":f["additional"]["file_location"] + "\n" + label2 if "file_location" in f["additional"] else "",
+                    "path": f["info"]["sharepath"] if "sharepath" in f["additional"] else "",
+                }
 
             elif type == "photo":
+                label = label + "\n" + f["info"]["takendate"]
                 label2 = f["info"]["takendate"]
-                image_url = ps.get_thumb_url(oid2,"large")
+                image_url = ps.get_photo_url(oid2) if picture_quality == "original" else ps.get_thumb_url(oid2, picture_quality)
                 data2 = image_url
-                item = xbmcgui.ListItem(title, label2, thumb_url, thumb_url, path=data2)
-                item.setInfo(
-                    "pictures",
-                    {"title":f["info"]["title"],
-                     "picturepath":f["additional"]["file_location"],
-                     "exif:resolution": "720,480" ,}
-                    )
+                #print "image_url=", data2
+                #data2 = urllib.quote(data2, ":/")
+                li_type = "pictures"
+                tags = {
+                    "title": label2,  #f["info"]["title"],
+                     "date": f["info"]["takendate"],
+                     "picturepath": f["additional"]["file_location"],
+                     "exif:resolution": "%s,%s" % (f["info"]["resolutionx"], f["info"]["resolutiony"]),
+                     #"exif:path": f["additional"]["file_location"],
+                     #"exif:name": f["info"]["name"],
+                     #"exif:filename": f["additional"]["file_location"],
+                     #"exif:"
+                     # TODO pārejie EXIF u.c. dati
+                }
 
             elif type=="video":
+                label = label + "\n" + f["info"]["takendate"]
                 label2 = f["info"]["takendate"]
-                item = xbmcgui.ListItem(title, label2, thumb_url, thumb_url, path=data2)
-                item.setInfo(
-                    'video', {
-                        "title": title,
+                li_type =  'video'
+                tags = {
+                        "title":  label ,
                         "plot": f["additional"]["file_location"],
+                        #TODO
                     }
-                )
-            item.setProperty("is_folder", "true" if is_folder else "")
+                if play_next:
+                    data2 = data2 + "&album=" + oid if "?" in data2 else data2 + "?album=" + oid
+                    #data2 = urllib.quote(data2, ":/")
+                    is_playable = ""
+                else:
+                    if video_quality == "original":
+                        quality_id = ""
+                    else:
+                        quality_id = f["additional"]["video_quality"][0]["id"]
+                    data2 = ps.get_video_url(oid2, quality_id)
+                    #data2 = urllib.quote(data2, ":/")
+
+            item = xbmcgui.ListItem(label=label, label2=label2, path=data2)
+            item.setArt({
+                "thumb": thumb_url,
+                "icon": thumb_url,
+                "fanart": thumb_url,
+            })
+            item.setInfo(li_type, tags)
+            item.setProperty("is_folder", is_folder)
+            item.setProperty('IsPlayable', is_playable)
             item.setProperty("url", data2)
-            items.append(item)
-            #xbmcplugin.addDirectoryItem(handle=plugin.handle, url=data2, listitem=item, isFolder=is_folder,
-                                        #totalItems=len(content["items"]))
+            #items.append(item)
+            xbmcplugin.addDirectoryItem(handle=plugin.handle, url=data2, listitem=item, isFolder=True if is_folder=="true" else False,
+                                        totalItems=len(content["items"]))
+
         if page_size <> -1 and len(content["items"]) == page_size:
             data2 = prefix+oid+"?page=%s" % (page+1)
+            #data2 = urllib.quote(data2, ":/")
             item = xbmcgui.ListItem("Next", "", "", "", data2)
             item.setInfo("Image", {"title":"Next"})
             item.setProperty("is_folder", "false")
             item.setProperty("url", data2)
-            items.append(item)
+            #items.append(item)
+            xbmcplugin.addDirectoryItem(handle=plugin.handle, url=data2, listitem=item, isFolder=True,
+                                                totalItems=len(content["items"]))
 
-        sort_methods = [SortMethod.FILE, SortMethod.DATE, SortMethod.DATE_TAKEN]
         view_mode_id =  get_view_mode(view_mode)
-        return plugin.finish(items, sort_methods=None, view_mode=view_mode_id, cache_to_disc=True, update_listing=False)
-        #xbmcplugin.endOfDirectory(plugin.handle, succeeded=True, updateListing=False, cacheToDisc=True)
+        xbmc.executebuiltin('Container.SetViewMode(%s)' % view_mode_id)
+        #sort_methods = [SortMethod.FILE, SortMethod.DATE, SortMethod.DATE_TAKEN]
+        #xbmcplugin.addSortMethod( plugin.handle, sortMethod=xbmcplugin.SORT_METHOD_GENRE )
+        xbmcplugin.endOfDirectory(plugin.handle, succeeded=True, updateListing=False, cacheToDisc=True)
+        #return plugin.finish(items, sort_methods=None, view_mode=view_mode_id, cache_to_disc=True, update_listing=False)
 
     elif oid.startswith("photo"):
         print "play_photo ", oid
         plugin.set_resolved_url(url)
 
     elif oid.startswith("video"):
-        try:
-            streams = ps.get_video_streams(oid)
-            js = ps.get_photo_info(oid)
-        except Exception,e:
-            plugin.notify(str(e),"",10000)
-            return None
-        if streams:
-            return play_video(streams)
-        else:
-            plugin.notify("No streams found!",10000)
-            return None
+        if play_next and "album" in qs:  # play playlist
+            print "play_playlist", data, qs
+            album_id = qs["album"]
+            try:
+                items = ps.get_album_list(album_id)
+            except Exception,e:
+                plugin.notify(str(e),"",10000)
+                return None
+            if items:
+                play_playlist(items["items"], oid)
+                return None
+            else:
+                plugin.notify("No items found!",10000)
+                return None
+        else:  # play one video
+            print "play_video"
+            try:
+                streams = ps.get_video_streams(oid)
+                js = ps.get_photo_info(oid)
+            except Exception,e:
+                plugin.notify(str(e),"",10000)
+                return None
+            if streams:
+                play_video(streams)
+                return None
+            else:
+                plugin.notify("No streams found!",10000)
+                return None
 
 def get_view_mode(vm):
     modes = {
     if skin in modes and vm in modes[skin]:
         view_mode = modes[skin][vm]
     else:
-        view_mode = 50
+        view_mode = 500
     return view_mode
 
 
+def play_playlist(items, oid):
+    playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
+    playlist.clear()
+    pos = -1
+    i = 0
+    for f in items:
+        if f["type"] in ("album","photo"):
+            continue
+
+        label = f["info"]["name"] + "\n" + f["info"]["takendate"]
+        label2 = f["additional"]["file_location"]
+        type = f["type"]
+        oid2 = f["id"]
+        if oid == oid2:
+            pos = i
+        #is_playable = True if type in ("video","photo") else False
+        is_folder = False if type in ("video","photo") else True
+        thumb_quality = thumbnail_quality if thumbnail_quality in  f["thumbnail_status"] else "small"
+        thumb_url = ps.get_thumb_url(f["id"],thumb_quality)
+        data2 = prefix+f["id"]
+        item = xbmcgui.ListItem(label, label2, path=data2)
+        item.setArt({
+            "thumb": thumb_url,
+            "icon": thumb_url,
+            "fanart": thumb_url,
+        })
+        item.setLabel2(label2)
+        item.setInfo(
+            'video', {
+                "title": label,
+                "plot": f["additional"]["file_location"],
+                #TODO
+            }
+        )
+        if video_quality == "original":
+            quality_id = ""
+        else:
+            quality_id = f["additional"]["video_quality"][0]["id"]
+        data2 = ps.get_video_url(oid2, quality_id)
+        #data2 = urllib.quote(data2, ":/")
+        item.setProperty("is_folder", "")
+        item.setProperty('IsPlayable', 'true')
+
+        #item.setPath(data2)
+        item.setProperty("url", data2)
+        playlist.add(data2, item)
+        i += 1
+
+    xbmc.Player().play(playlist, startpos=pos)
+
+
 def play_video(streams):
     stream = streams[0]
     subfiles = []
     item = ListItem(label=stream["name"], thumbnail=stream["img"], path=stream["url"])
     item.set_info("video",{"plot":stream["desc"]})
     item.is_folder = False
-    item.set_is_playable(True)
-    plugin.play_video(item)
+    #item.set_is_playable(True)
+    #plugin.play_video(item)
+    item2 = xbmcgui.ListItem("label", "label2", path=stream["url"])
+    item2.setProperty('IsPlayable', 'true')
+    xbmc.Player().play(item=stream["url"], listitem=item2)
+    #xbmcplugin.setResolvedUrl(plugin.handle, True, listitem=item2)
+
 
 
 if __name__ == '__main__':

addon.xml

 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<addon version="0.1.7" id="plugin.image.photostation" name="PhotoStation" provider-name="ivars777"  >
+<addon version="0.1.15" id="plugin.image.photostation" name="PhotoStation" provider-name="ivars777"  >
   <requires>
     <import addon="xbmc.python" version="2.1.0"/>
     <import addon="script.module.requests" />

changelog.md

+**0.1.8** (20.05.2018):
+- addon settings added
+
+**0.1.5** (14.02.2017):
+- addon settings added
+
 **0.1.1** (12.02.2017):
 - initial exprerimental version
 
-**0.1.5** (14.02.2016):
-- addon settings added

kmake.bat

 set ipk_dir=ipkg\
 set release_dir=release\
 set repo_dir=..\repo\
-set feed_dir=w:\repo\
+set feed_dir=q:\web\repo\
 
 set AR=\MinGW\bin\ar.exe
 set TAR=\MinGW\msys\1.0\bin\tar.exe
 python -c "import hashlib; print hashlib.md5(open(r'%repo_dir%%pack_name%\%pack_name%-%ver%.zip','r').read()).hexdigest()" >%repo_dir%%pack_name%\%pack_name%-%ver%.zip.md5
 
 git add %release_dir%%pack_name%-%ver%.zip
+rm -r -f "%pack_name%"
 
 if not ()==(%1%) (
     git commit -m %ver%
 
     pushd  %repo_dir%..
     call update_repo.bat
-    xcopy /s /y repo %feed_dir%
+    rem xcopy /s /y /u repo %feed_dir%
+    robocopy repo %feed_dir%  addons.* /copy:dat
+    robocopy repo\%pack_name% q:\web\repo\%pack_name% /copy:DAT /xo
     popd
 )
 pause

kodiswift/plugin.py

         # url as well
         if url is None:
             url = sys.argv[0]
-            if len(sys.argv) == 3:
+            if len(sys.argv) >= 3:
                 url += sys.argv[2]
         if handle is None:
             handle = sys.argv[1]

project.wpr

                                        (u'run interactive',
         ''))}
 [user attributes]
-debug.breakpoints = {loc('addon.py'): {3L: (0,
+debug.breakpoints = {loc('addon.py'): {15L: (0,
         None,
         1,
         0),
-                                       120L: (0,
+                                       131L: (0,
+        None,
+        1,
+        0),
+                                       140L: (0,
+        None,
+        1,
+        0),
+                                       185L: (0,
+        None,
+        1,
+        0),
+                                       302L: (0,
+        None,
+        1,
+        0),
+                                       307L: (0,
         None,
         1,
         0)},
         None,
         1,
         0)},
-                     loc('kodiswift/xbmcmixin.py'): {357L: (0,
-        None,
-        1,
-        0),
-        373L: (0,
-               None,
-               1,
-               0),
-        375L: (0,
-               None,
-               1,
-               0)},
-                     loc('resources/lib/photostation_api.py'): {200L: (0,
+                     loc('resources/lib/photostation_api.py'): {380L: (0,
         None,
         1,
         0),
-        216: (0,
-              None,
-              1,
-              0),
-        228L: (0,
+        403L: (0,
                None,
                1,
                0)},
             None,
             1,
             0)},
-                     loc('unknown:<untitled> #1'): {2: (0,
+                     loc('unknown:<untitled> #1'): {10: (0,
         None,
         1,
         0)},
-                     loc('unknown:<untitled> #2'): {10: (0,
+                     loc('unknown:<untitled> #2'): {2: (0,
         None,
         1,
         0)}}
                          loc('run.py'): [u'run interactive'],
                          loc('run2.py'): [u'run interactive']}
 debug.run-args = {}
-debug.var-col-widths = [0.41872791519434627,
-                        0.5812720848056537]
+debug.var-col-widths = [0.5823244552058111,
+                        0.4176755447941889]
 guimgr.overall-gui-state = {'windowing-policy': 'combined-window',
                             'windows': [{'name': 'F8FpRDICw7YHXG3HV2rBc63asU'\
         'LBT7JH',
-        'size-state': 'maximized',
+        'size-state': '',
         'type': 'dock',
         'view': {'area': 'tall',
                  'constraint': None,
                  'current_pages': [0,
                                    1],
                  'full-screen': False,
-                 'notebook_display': 'normal',
+                 'notebook_display': 'tabs only',
                  'notebook_percent': 0.2797173732335827,
                  'override_title': None,
                  'pagelist': [('project',
                                {'tree-state': {'file-sort-method': 'by name',
         'list-files-first': 0,
         'tree-states': {'deep': {'expanded-nodes': [(0,),
-        (5,),
-        (5,
-         0),
-        (5,
-         0,
-         0),
-        (5,
-         1)],
-                                 'selected-nodes': [(5,
-        0,
-        0,
-        0)],
+        (7,)],
+                                 'selected-nodes': [],
                                  'top-node': (0,)}},
         'tree-style': 'deep'}}),
                               ('snippets',
         'top-node': [('generic attribute',
                       loc('../../../Python27/Lib/site-packages/win32com/client/dynamic.py'),
                       'ALL_INVOKE_TYPES')]},
-        loc('unknown:<untitled> #5'): {'column-widths': [1.0],
-                                       'expanded-nodes': [],
+        loc('unknown:<untitled> #3'): {'expanded-nodes': [],
                                        'selected-nodes': [],
                                        'top-node': None},
-        loc('unknown:<untitled> #6'): {'expanded-nodes': [],
+        loc('unknown:<untitled> #4'): {'column-widths': [1.0],
+                                       'expanded-nodes': [],
                                        'selected-nodes': [],
                                        'top-node': None},
-        loc('unknown:<untitled> #4'): {'column-widths': [1.0],
+        loc('unknown:<untitled> #6'): {'column-widths': [1.0],
                                        'expanded-nodes': [],
                                        'selected-nodes': [],
                                        'top-node': None},
-        loc('unknown:<untitled> #3'): {'expanded-nodes': [],
+        loc('unknown:<untitled> #5'): {'expanded-nodes': [],
                                        'selected-nodes': [],
                                        'top-node': None}},
                                 'browse_mode': u'Current Module',
         'current_pages': [3,
                           1],
         'notebook_display': 'normal',
-        'notebook_percent': 0.4243394715772618,
+        'notebook_percent': 0.40883534136546185,
         'override_title': None,
         'pagelist': [('debug-breakpoints',
                       'wide',
                                        'fRegexFlags': 46,
                                        'fReplaceText': '',
                                        'fReverse': False,
-                                       'fSearchText': u'next',
+                                       'fSearchText': u'page',
                                        'fStartPos': 0,
                                        'fStyle': 'text',
                                        'fWholeWords': False,
         -1,
         -1),
                        'attrib-starts': [],
-                       'first-line': 6L,
+                       'first-line': 22L,
                        'folded-linenos': [],
-                       'history': {None: ['plugin.get_setting("picture_quali'\
-        'ty", str)\n',
-        'plugin.get_setting("video_quality")\n',
-        'plugin.get_setting("picture_quality")\n',
-        'len(content)\n']},
+                       'history': {None: ['plugin.request\n',
+        'plugin.request.url\n',
+        'plugin.request.path\n',
+        'plugin.request.query_string\n',
+        'sys.argv\n',
+        'sys.argv[0]\n',
+        'sys.argv[2]\n',
+        'len(sys.argv)\n']},
                        'launch-id': None,
-                       'sel-line': 16L,
-                       'sel-line-start': 320L,
-                       'selection_end': 320L,
-                       'selection_start': 320L,
+                       'sel-line': 31L,
+                       'sel-line-start': 866L,
+                       'selection_end': 866L,
+                       'selection_start': 866L,
                        'zoom': 0L}),
                      ('debug-watch',
                       'wide',
                       {'node-states': [('eval',
         u'js'),
                                        ('eval',
-        u'item2'),
+        u'ps'),
                                        ('eval',
-        u'f')],
+        u'f'),
+                                       ('eval',
+        u'content'),
+                                       ('eval',
+        u'items')],
                        'tree-state': {'expanded-nodes': [],
-                                      'selected-nodes': [(0,)],
+                                      'selected-nodes': [(4,)],
                                       'top-node': (0,)}}),
                      ('messages',
                       'wide',
                       2,
                       {'current-domain': 0}),
-                     ('debug-modules',
-                      'wide',
-                      1,
-                      {}),
-                     ('os-command',
-                      'wide',
-                      1,
-                      {'last-percent': 0.8,
-                       'toolbox-percent': 1.0,
-                       'toolbox-tree-sel': ''}),
                      ('python-shell',
                       'wide',
                       2,
                        'sel-line-start': 174L,
                        'selection_end': 174L,
                        'selection_start': 174L,
-                       'zoom': 0L})],
+                       'zoom': 0L}),
+                     ('debug-modules',
+                      'wide',
+                      1,
+                      {}),
+                     ('os-command',
+                      'wide',
+                      1,
+                      {'last-percent': 0.8,
+                       'toolbox-percent': 1.0,
+                       'toolbox-tree-sel': ''})],
         'primary_view_state': {'editor_states': ('horizontal',
         1.0,
-        ({'bookmarks': ([[loc('resources/lib/photostation_api.py'),
-                          {'attrib-starts': [('PhotoStationAPI',
-        7),
-        ('PhotoStationAPI._check_url',
-         198)],
-                           'first-line': 192L,
-                           'folded-linenos': [],
-                           'sel-line': 203L,
-                           'sel-line-start': 9529L,
-                           'selection_end': 9529L,
-                           'selection_start': 9529L,
+        ({'bookmarks': ([[loc('addon.py'),
+                          {'attrib-starts': [('main',
+        37)],
+                           'first-line': 43L,
+                           'folded-linenos': [228L],
+                           'sel-line': 52L,
+                           'sel-line-start': 1782L,
+                           'selection_end': 1798L,
+                           'selection_start': 1794L,
                            'zoom': 0L},
-                          1516922377.77],
+                          1531953967.139],
                          [loc('addon.py'),
-                          {'attrib-starts': [],
-                           'first-line': 18L,
-                           'folded-linenos': [134L],
-                           'sel-line': 21L,
-                           'sel-line-start': 685L,
-                           'selection_end': 745L,
-                           'selection_start': 703L,
-                           'zoom': 0L},
-                          1516922637.041],
-                         [loc('resources/settings.xml'),
-                          {'attrib-starts': [],
-                           'first-line': 0L,
-                           'folded-linenos': [],
-                           'sel-line': 10L,
-                           'sel-line-start': 849L,
-                           'selection_end': 878L,
-                           'selection_start': 873L,
+                          {'attrib-starts': [('main',
+        37)],
+                           'first-line': 43L,
+                           'folded-linenos': [228L],
+                           'sel-line': 53L,
+                           'sel-line-start': 1807L,
+                           'selection_end': 1819L,
+                           'selection_start': 1815L,
                            'zoom': 0L},
-                          1516922728.157],
-                         [loc('resources/settings.xml'),
-                          {'attrib-starts': [],
-                           'first-line': 2L,
-                           'folded-linenos': [],
-                           'sel-line': 10L,
-                           'sel-line-start': 849L,
-                           'selection_end': 899L,
-                           'selection_start': 884L,
+                          1531953967.755],
+                         [loc('addon.py'),
+                          {'attrib-starts': [('main',
+        37)],
+                           'first-line': 43L,
+                           'folded-linenos': [228L],
+                           'sel-line': 55L,
+                           'sel-line-start': 1834L,
+                           'selection_end': 1846L,
+                           'selection_start': 1842L,
                            'zoom': 0L},
-                          1516922737.378],
-                         [loc('resources/settings.xml'),
-                          {'attrib-starts': [],
-                           'first-line': 2L,
-                           'folded-linenos': [],
-                           'sel-line': 11L,
-                           'sel-line-start': 966L,
-                           'selection_end': 1017L,
-                           'selection_start': 1017L,
+                          1531953968.128],
+                         [loc('addon.py'),
+                          {'attrib-starts': [('main',
+        37)],
+                           'first-line': 43L,
+                           'folded-linenos': [228L],
+                           'sel-line': 55L,
+                           'sel-line-start': 1834L,
+                           'selection_end': 1861L,
+                           'selection_start': 1857L,
                            'zoom': 0L},
-                          1516923005.027],
+                          1531953968.496],
                          [loc('addon.py'),
-                          {'attrib-starts': [],
-                           'first-line': 13L,
-                           'folded-linenos': [134L],
-                           'sel-line': 23L,
-                           'sel-line-start': 749L,
-                           'selection_end': 749L,
-                           'selection_start': 749L,
+                          {'attrib-starts': [('main',
+        37)],
+                           'first-line': 66L,
+                           'folded-linenos': [228L],
+                           'sel-line': 75L,
+                           'sel-line-start': 2620L,
+                           'selection_end': 2634L,
+                           'selection_start': 2628L,
                            'zoom': 0L},
-                          1516923078.023],
-                         [loc('resources/settings.xml'),
-                          {'attrib-starts': [],
-                           'first-line': 2L,
-                           'folded-linenos': [],
-                           'sel-line': 10L,
-                           'sel-line-start': 849L,
-                           'selection_end': 899L,
-                           'selection_start': 899L,
+                          1531953988.159],
+                         [loc('addon.py'),
+                          {'attrib-starts': [('main',
+        37)],
+                           'first-line': 66L,
+                           'folded-linenos': [228L],
+                           'sel-line': 75L,
+                           'sel-line-start': 2620L,
+                           'selection_end': 2646L,
+                           'selection_start': 2642L,
                            'zoom': 0L},
-                          1516923107.786],
+                          1531953988.55],
                          [loc('addon.py'),
                           {'attrib-starts': [('main',
-        32)],
-                           'first-line': 49L,
-                           'folded-linenos': [134L],
-                           'sel-line': 57L,
-                           'sel-line-start': 1733L,
-                           'selection_end': 1768L,
-                           'selection_start': 1754L,
+        37)],
+                           'first-line': 66L,
+                           'folded-linenos': [228L],
+                           'sel-line': 75L,
+                           'sel-line-start': 2620L,
+                           'selection_end': 2668L,
+                           'selection_start': 2664L,
                            'zoom': 0L},
-                          1516923380.562],
-                         [loc('resources/lib/photostation_api.py'),
-                          {'attrib-starts': [('PhotoStationAPI',
-        7),
-        ('PhotoStationAPI.get_album_list',
-         33)],
-                           'first-line': 27L,
-                           'folded-linenos': [],
-                           'sel-line': 33L,
-                           'sel-line-start': 988L,
-                           'selection_end': 1026L,
-                           'selection_start': 1018L,
+                          1531953988.847],
+                         [loc('addon.py'),
+                          {'attrib-starts': [('main',
+        37)],
+                           'first-line': 66L,
+                           'folded-linenos': [228L],
+                           'sel-line': 75L,
+                           'sel-line-start': 2620L,
+                           'selection_end': 2680L,
+                           'selection_start': 2676L,
                            'zoom': 0L},
-                          1516923420.879],
+                          1531953989.142],
                          [loc('addon.py'),
                           {'attrib-starts': [('main',
-        32)],
-                           'first-line': 49L,
-                           'folded-linenos': [134L],
-                           'sel-line': 57L,
-                           'sel-line-start': 1733L,
-                           'selection_end': 1773L,
-                           'selection_start': 1769L,
+        37)],
+                           'first-line': 66L,
+                           'folded-linenos': [228L],
+                           'sel-line': 76L,
+                           'sel-line-start': 2686L,
+                           'selection_end': 2712L,
+                           'selection_start': 2708L,
                            'zoom': 0L},
-                          1516923434.323],
-                         [loc('resources/lib/photostation_api.py'),
-                          {'attrib-starts': [('PhotoStationAPI',
-        7),
-        ('PhotoStationAPI.get_album_list',
-         33)],
-                           'first-line': 27L,
-                           'folded-linenos': [],
-                           'sel-line': 34L,
-                           'sel-line-start': 1032L,
-                           'selection_end': 1070L,
-                           'selection_start': 1065L,
+                          1531953989.451],
+                         [loc('addon.py'),
+                          {'attrib-starts': [('main',
+        37)],
+                           'first-line': 66L,
+                           'folded-linenos': [228L],
+                           'sel-line': 76L,
+                           'sel-line-start': 2686L,
+                           'selection_end': 2733L,
+                           'selection_start': 2729L,
                            'zoom': 0L},
-                          1516923476.237],
+                          1531953989.779],
                          [loc('addon.py'),
                           {'attrib-starts': [('main',
-        32)],
-                           'first-line': 49L,
-                           'folded-linenos': [133L],
-                           'sel-line': 55L,
-                           'sel-line-start': 1677L,
-                           'selection_end': 1694L,
-                           'selection_start': 1694L,
+        37)],
+                           'first-line': 153L,
+                           'folded-linenos': [228L],
+                           'sel-line': 165L,
+                           'sel-line-start': 7294L,
+                           'selection_end': 7309L,
+                           'selection_start': 7305L,
                            'zoom': 0L},
-                          1516923530.207],
-                         [loc('resources/settings.xml'),
+                          1531953991.372],
+                         [loc('addon.py'),
                           {'attrib-starts': [],
-                           'first-line': 2L,
-                           'folded-linenos': [],
-                           'sel-line': 2L,
-                           'sel-line-start': 69L,
-                           'selection_end': 71L,
-                           'selection_start': 69L,
+                           'first-line': 310L,
+                           'folded-linenos': [228L],
+                           'sel-line': 321L,
+                           'sel-line-start': 12716L,
+                           'selection_end': 12716L,
+                           'selection_start': 12716L,
                            'zoom': 0L},
-                          1516923564.218],
-                         [loc('addon.py'),
-                          {'attrib-starts': [('main',
-        33)],
-                           'first-line': 41L,
-                           'folded-linenos': [134L],
-                           'sel-line': 56L,
-                           'sel-line-start': 1735L,
-                           'selection_end': 1748L,
-                           'selection_start': 1743L,
+                          1531954130.795],
+                         [loc('kodiswift/plugin.py'),
+                          {'attrib-starts': [('Plugin',
+        27),
+        ('Plugin._parse_request',
+         341)],
+                           'first-line': 347L,
+                           'folded-linenos': [],
+                           'sel-line': 356L,
+                           'sel-line-start': 13246L,
+                           'selection_end': 13246L,
+                           'selection_start': 13246L,
                            'zoom': 0L},
-                          1516924026.579],
-                         [loc('resources/lib/photostation_api.py'),
-                          {'attrib-starts': [('PhotoStationAPI',
-        7),
-        ('PhotoStationAPI.get_album_list',
-         33)],
-                           'first-line': 27L,
+                          1531954225.148],
+                         [loc('kodiswift/request.py'),
+                          {'attrib-starts': [('Request',
+        20),
+        ('Request.__init__',
+         22)],
+                           'first-line': 16L,
                            'folded-linenos': [],
-                           'sel-line': 34L,
-                           'sel-line-start': 1032L,
-                           'selection_end': 1070L,
-                           'selection_start': 1065L,
+                           'sel-line': 37L,
+                           'sel-line-start': 1056L,
+                           'selection_end': 1056L,
+                           'selection_start': 1056L,
                            'zoom': 0L},
-                          1516924067.572],
+                          1531954245.475],
                          [loc('addon.py'),
-                          {'attrib-starts': [('main',
-        32)],
-                           'first-line': 62L,
-                           'folded-linenos': [142L],
-                           'sel-line': 118L,
-                           'sel-line-start': 4962L,
-                           'selection_end': 4962L,
-                           'selection_start': 4962L,
+                          {'attrib-starts': [],
+                           'first-line': 309L,
+                           'folded-linenos': [228L],
+                           'sel-line': 321L,
+                           'sel-line-start': 12716L,
+                           'selection_end': 12716L,
+                           'selection_start': 12716L,
                            'zoom': 0L},
-                          1516926293.565],
-                         [loc('kodiswift/xbmcmixin.py'),
-                          {'attrib-starts': [('XBMCMixin',
-        21),
-        ('XBMCMixin.set_resolved_url',
-         340)],
-                           'first-line': 365L,
+                          1531954266.378],
+                         [loc('kodiswift/plugin.py'),
+                          {'attrib-starts': [('Plugin',
+        27),
+        ('Plugin._parse_request',
+         341)],
+                           'first-line': 342L,
                            'folded-linenos': [],
-                           'sel-line': 374L,
-                           'sel-line-start': 15799L,
-                           'selection_end': 15854L,
-                           'selection_start': 15854L,
+                           'sel-line': 352L,
+                           'sel-line-start': 13112L,
+                           'selection_end': 13143L,
+                           'selection_start': 13143L,
                            'zoom': 0L},
-                          1516926360.838],
+                          1531954319.585],
                          [loc('addon.py'),
-                          {'attrib-starts': [('main',
-        32)],
-                           'first-line': 42L,
-                           'folded-linenos': [142L],
-                           'sel-line': 47L,
-                           'sel-line-start': 1560L,
-                           'selection_end': 1584L,
-                           'selection_start': 1584L,
-                           'zoom': 0L},
-                          1516927419.315],
-                         [loc('addon.py'),
-                          {'attrib-starts': [('main',
-        32)],
-                           'first-line': 107L,
-                           'folded-linenos': [],
-                           'sel-line': 113L,
-                           'sel-line-start': 4646L,
-                           'selection_end': 4646L,
-                           'selection_start': 4646L,
+                          {'attrib-starts': [],
+                           'first-line': 309L,
+                           'folded-linenos': [228L],
+                           'sel-line': 321L,
+                           'sel-line-start': 12716L,
+                           'selection_end': 12716L,
+                           'selection_start': 12716L,
                            'zoom': 0L},
-                          1516927851.25],
+                          1531954326.398],
                          [loc('kodiswift/plugin.py'),
                           {'attrib-starts': [('Plugin',
         27),
-        ('Plugin._dispatch',
-         318)],
-                           'first-line': 305L,
+        ('Plugin._parse_request',
+         341)],
+                           'first-line': 347L,
+                           'folded-linenos': [],
+                           'sel-line': 356L,
+                           'sel-line-start': 13246L,
+                           'selection_end': 13246L,
+                           'selection_start': 13246L,
+                           'zoom': 0L},
+                          1531954347.816],
+                         [loc('kodiswift/request.py'),
+                          {'attrib-starts': [('Request',
+        20),
+        ('Request.__init__',
+         22)],
+                           'first-line': 33L,
                            'folded-linenos': [],
-                           'sel-line': 325L,
-                           'sel-line-start': 12001L,
-                           'selection_end': 12040L,
-                           'selection_start': 12040L,
+                           'sel-line': 45L,
+                           'sel-line-start': 1422L,
+                           'selection_end': 1422L,
+                           'selection_start': 1422L,
+                           'zoom': 0L},
+                          1531954379.77],
+                         [loc('addon.py'),
+                          {'attrib-starts': [],
+                           'first-line': 9L,
+                           'folded-linenos': [228L],
+                           'sel-line': 14L,
+                           'sel-line-start': 384L,
+                           'selection_end': 384L,
+                           'selection_start': 384L,
                            'zoom': 0L},
-                          1516927872.463]],
+                          1531954540.55]],
                         20),
-          'current-loc': loc('addon.py'),
+          'current-loc': loc('addon.xml'),
           'editor-state-list': [(loc('addon.xml'),
                                  {'attrib-starts': [],
                                   'first-line': 0L,
                                   'folded-linenos': [],
-                                  'sel-line': 8L,
-                                  'sel-line-start': 402L,
-                                  'selection_end': 421L,
-                                  'selection_start': 421L,
+                                  'sel-line': 1L,
+                                  'sel-line-start': 57L,
+                                  'selection_end': 79L,
+                                  'selection_start': 79L,
                                   'zoom': 0L}),
                                 (loc('addon.py'),
-                                 {'attrib-starts': [('main',
-        32)],
-                                  'first-line': 106L,
-                                  'folded-linenos': [],
-                                  'sel-line': 114L,
-                                  'sel-line-start': 4696L,
-                                  'selection_end': 4696L,
-                                  'selection_start': 4696L,
+                                 {'attrib-starts': [],
+                                  'first-line': 9L,
+                                  'folded-linenos': [228L],
+                                  'sel-line': 14L,
+                                  'sel-line-start': 384L,
+                                  'selection_end': 384L,
+                                  'selection_start': 384L,
                                   'zoom': 0L}),
                                 (loc('resources/lib/photostation_api.py'),
                                  {'attrib-starts': [('PhotoStationAPI',
         7),
-        ('PhotoStationAPI.get_album_list',
-         33)],
-                                  'first-line': 27L,
+        ('PhotoStationAPI.get_category_list',
+         98)],
+                                  'first-line': 92L,
                                   'folded-linenos': [],
-                                  'sel-line': 34L,
-                                  'sel-line-start': 1032L,
-                                  'selection_end': 1070L,
-                                  'selection_start': 1065L,
+                                  'sel-line': 104L,
+                                  'sel-line-start': 5012L,
+                                  'selection_end': 5012L,
+                                  'selection_start': 5012L,
                                   'zoom': 0L}),
                                 (loc('changelog.md'),
                                  {'attrib-starts': [],
                                   'zoom': 0L}),
                                 (loc('resources/settings.xml'),
                                  {'attrib-starts': [],
-                                  'first-line': 2L,
+                                  'first-line': 0L,
                                   'folded-linenos': [],
-                                  'sel-line': 2L,
-                                  'sel-line-start': 69L,
-                                  'selection_end': 71L,
-                                  'selection_start': 69L,
+                                  'sel-line': 13L,
+                                  'sel-line-start': 1171L,
+                                  'selection_end': 1171L,
+                                  'selection_start': 1171L,
                                   'zoom': 0L}),
                                 (loc('kodiswift/listitem.py'),
-                                 {'attrib-starts': [('ListItem',
-        20),
-        ('ListItem.__eq__',
-         325)],
-                                  'first-line': 310L,
+                                 {'attrib-starts': [],
+                                  'first-line': 0L,
                                   'folded-linenos': [],
-                                  'sel-line': 327L,
-                                  'sel-line-start': 10428L,
-                                  'selection_end': 10428L,
-                                  'selection_start': 10428L,
+                                  'sel-line': 0L,
+                                  'sel-line-start': 0L,
+                                  'selection_end': 28L,
+                                  'selection_start': 0L,
                                   'zoom': 0L}),
                                 (loc('kodiswift/xbmcmixin.py'),
                                  {'attrib-starts': [('XBMCMixin',
         21),
-        ('XBMCMixin.set_resolved_url',
-         340)],
-                                  'first-line': 365L,
+        ('XBMCMixin._listitemify',
+         531)],
+                                  'first-line': 532L,
                                   'folded-linenos': [],
-                                  'sel-line': 374L,
-                                  'sel-line-start': 15799L,
-                                  'selection_end': 15854L,
-                                  'selection_start': 15854L,
+                                  'sel-line': 543L,
+                                  'sel-line-start': 23072L,
+                                  'selection_end': 23119L,
+                                  'selection_start': 23110L,
                                   'zoom': 0L}),
                                 (loc('kodiswift/mockxbmc/xbmcgui.py'),
                                  {'attrib-starts': [('ListItem',
                                   'zoom': 0L}),
                                 (loc('resources/language/English/strings.xml'),
                                  {'attrib-starts': [],
-                                  'first-line': 5L,
+                                  'first-line': 15L,
                                   'folded-linenos': [],
-                                  'sel-line': 18L,
-                                  'sel-line-start': 647L,
-                                  'selection_end': 666L,
-                                  'selection_start': 661L,
+                                  'sel-line': 21L,
+                                  'sel-line-start': 785L,
+                                  'selection_end': 785L,
+                                  'selection_start': 785L,
                                   'zoom': 0L}),
                                 (loc('kodiswift/plugin.py'),
                                  {'attrib-starts': [('Plugin',
         27),
-        ('Plugin._dispatch',
-         318)],
-                                  'first-line': 305L,
+        ('Plugin._parse_request',
+         341)],
+                                  'first-line': 347L,
                                   'folded-linenos': [],
-                                  'sel-line': 325L,
-                                  'sel-line-start': 12001L,
-                                  'selection_end': 12040L,
-                                  'selection_start': 12040L,
+                                  'sel-line': 356L,
+                                  'sel-line-start': 13246L,
+                                  'selection_end': 13246L,
+                                  'selection_start': 13246L,
                                   'zoom': 0L})],
           'has-focus': True,
           'locked': False},
           loc('settings.xml'),
           loc('../../../../Python27/Lib/site-packages/xbmcswift2/mockxbmc/xbmcgui.py'),
           loc('../../../../Python27/Lib/site-packages/kodiswift/listitem.py')])),
-                               'open_files': [u'addon.xml',
-        u'changelog.md',
+                               'open_files': [u'changelog.md',
         u'kodiswift/cli/app.py',
         u'kodiswift/listitem.py',
         u'kodiswift/mockxbmc/xbmcgui.py',
+        u'kodiswift/xbmcmixin.py',
         u'resources/language/English/strings.xml',
-        u'resources/settings.xml',
         u'resources/lib/photostation_api.py',
-        u'kodiswift/xbmcmixin.py',
+        u'resources/settings.xml',
+        u'kodiswift/plugin.py',
         u'addon.py',
+        u'addon.xml',
         u'../../../../Python27/Lib/site-packages/kodiswift/listitem.py',
         u'../../../../Python27/Lib/site-packages/xbmcswift2/mockxbmc/xbmcgui.py',
         u'addon.py',
         u'resources/settings.xml',
         u'settings.xml']},
         'saved_notebook_display': None,
-        'split_percents': {0: 0.5200166805671392},
+        'split_percents': {0: 0.3710232158211522},
         'splits': 2,
         'tab_location': 'top',
         'user_data': {}},
                  'splits': 2,
                  'tab_location': 'left',
                  'user_data': {}},
-        'window-alloc': (146,
+        'window-alloc': (167,
                          0,
-                         2414,
-                         1440)}]}
-guimgr.recent-documents = [loc('addon.py'),
+                         2417,
+                         1462)}]}
+guimgr.recent-documents = [loc('addon.xml'),
+                           loc('addon.py'),
+                           loc('kodiswift/request.py'),
                            loc('kodiswift/plugin.py'),
-                           loc('kodiswift/xbmcmixin.py'),
-                           loc('resources/lib/photostation_api.py'),
                            loc('resources/settings.xml'),
+                           loc('resources/lib/photostation_api.py'),
+                           loc('changelog.md'),
+                           loc('kodiswift/xbmcmixin.py'),
                            loc('resources/language/English/strings.xml'),
-                           loc('kodiswift/cli/app.py'),
-                           loc('kodiswift/listitem.py'),
-                           loc('kodiswift/mockxbmc/xbmcgui.py'),
-                           loc('addon.xml'),
-                           loc('changelog.md')]
+                           loc('kodiswift/listitem.py')]
 guimgr.visual-state = {loc('../../../../Python27/Lib/site-packages/kodiswift/listitem.py'): {'a'\
         'ttrib-starts': [],
         'first-line': 0L,
         'sel-line-start': 17420L,
         'selection_end': 17420L,
         'selection_start': 17420L},
-                       loc('../../../../Python27/Lib/site-packages/pkg_resources/__init__.py'): {'a'\
-        'ttrib-starts': [],
-        'first-line': 0L,
-        'folded-linenos': [],
-        'sel-line': 2L,
-        'sel-line-start': 20L,
-        'selection_end': 40L,
-        'selection_start': 40L},
                        loc('../../../../Python27/Lib/site-packages/xbmcswift2/cli/app.py'): {'a'\
         'ttrib-starts': [('once',
                           146)],
         'sel-line-start': 29,
         'selection_end': 36,
         'selection_start': 36},
+                       loc('../../../../Python27/lib/site-packages/pkg_resources/__init__.py'): {'a'\
+        'ttrib-starts': [],
+        'first-line': 0L,
+        'folded-linenos': [],
+        'sel-line': 2L,
+        'sel-line-start': 20L,
+        'selection_end': 40L,
+        'selection_start': 40L},
                        loc('addon.py'): {'attrib-starts': [('main',
         23)],
         'first-line': 92L,
         'sel-line-start': 92L,
         'selection_end': 101L,
         'selection_start': 95L,
+        'zoom': 0L},
+                       loc('plugin.image.photostation/resources/lib/photostation_api.py'): {'a'\
+        'ttrib-starts': [('PhotoStationAPI',
+                          7),
+                         ('PhotoStationAPI.__init__',
+                          9)],
+        'first-line': 0L,
+        'folded-linenos': [],
+        'sel-line': 10L,
+        'sel-line-start': 246L,
+        'selection_end': 246L,
+        'selection_start': 246L,
         'zoom': 0L},
                        loc('plugin.video.playstream/resources/lib/ContentSources.py'): {'a'\
         'ttrib-starts': [],
         'sel-line-start': 0L,
         'selection_end': 0L,
         'selection_start': 0L,
+        'zoom': 0L},
+                       loc('../plugin.video.playstream/download_service.py'): {'a'\
+        'ttrib-starts': [],
+        'first-line': 0L,
+        'folded-linenos': [],
+        'sel-line': 10L,
+        'sel-line-start': 314L,
+        'selection_end': 337L,
+        'selection_start': 337L,
+        'zoom': 0L},
+                       loc('../script.module.twisted/lib/twisted/internet/ssl.py'): {'a'\
+        'ttrib-starts': [],
+        'first-line': 49L,
+        'folded-linenos': [],
+        'sel-line': 58L,
+        'sel-line-start': 2524L,
+        'selection_end': 2524L,
+        'selection_start': 2524L,
         'zoom': 0L},
                        loc('../untitled-1.py'): {'attrib-starts': [],
         'first-line': 0,
                                    'versioncontrol.svn.extra-global-args': '',
                                    'versioncontrol.svn.svnadmin-executable': u'svnadmin'}})
 search.search-history = [u'(o',
-                         u'picture_quality',
-                         u'sort',
-                         u'played',
-                         u'get_player',
-                         u'get_played',
-                         u'item.',
-                         u'add_sort_method',
-                         u'_settings',
-                         u'"desc',
-                         u'setContent',
-                         u'as_tuple',
-                         u'add_items',
-                         u'folder',
-                         u'_listitem',
-                         u'pictures',
-                         u'info_type',
-                         u'infola',
-                         u'ListItem',
-                         u'item']
+                         u'page',
+                         u'quote',
+                         u'unquote',
+                         u'next',
+                         u'"video"',
+                         u'_url =',
+                         u'_url=',
+                         u'img =',
+                         u'data2 =',
+                         u'keep',
+                         u'call2',
+                         u'label2',
+                         u'playlist',
+                         u'oid',
+                         u'path=',
+                         u'path',
+                         u'set_con',
+                         u'label',
+                         u'qs']
 testing.stored-results = (1,
                           [],
                           {})

resources/language/English/strings.xml

   <string id="50008">Slideshow repet</string>
   <string id="50009">Slideshow random</string>
   <string id="50010">Start page</string>
+  <string id="50011">Play next video</string>
+  <string id="50012">Thumbnail quality</string>
 
   <string id="50101">PhotoStation server url</string>
   <string id="50102">Username</string>

resources/lib/photostation_api.py

+# -*- coding: utf-8 -*-
 import os,os.path
 import requests, urllib, urlparse
 import json
 
-
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
 
 class PhotoStationAPI():
 Accept-Language: en-US,en;q=0.5
 Referer: %s/photo/
 """%ps_url)
+        self.api = self._call2("query.php", "api=SYNO.API.Info&method=query&version=1&query=all")
 
     def login(self,user,password):
         data = "api=SYNO.PhotoStation.Auth&method=login&version=1&username=%s&password=%s&remember_me=on"%(user,password)
         js = self._call2("auth.php",data)
-        if not js["success"]:
-            raise Exception("Can not login")
-        self.sid=js["data"]["sid"]
+        self.sid=js["sid"]
         self.user = user
         return self.sid
 
                         ):
         data = "api=SYNO.PhotoStation.Album&method=list&version=1&offset=%s&limit=%s&recursive=false&type=album,photo,video&additional=%s&sort_direction=%s&sort_by=%s&ignore=thumbnail&id=%s"%(
             offset,limit,additional,sort_direction,sort_by,album_id)
-        js = self._call2("album.php",data)
-        if js["success"] and "data" in js:
-            return js["data"]
-        else:
-            raise Exception("Error reading album list")
-
+        return self._call2("album.php",data)
 
     def get_album_list2( self, album_id="",
                     offset=0,limit=-1,
             ])
         return lst
 
+    def get_categories(self):
+        return self.call_api("Category", "list", offset=0, limit=120)
+
     def get_album_info(self,album_id=""):
         data = "id=%s&additional=album_sorting,item_count&api=SYNO.PhotoStation.Album&method=getinfo&version=1&ps_username=%s"%(
             album_id,self.user)
-        js = self._call2("album.php",data)
-        if js["success"] and "data" in js:
-            return js["data"]
-        else:
-            raise Exception("Error reading album info")
+        return self._call2("album.php",data)
+
+    def get_category_list2(self):
+        return self.call_api("Category", "list", offset=0, limit=-1)
 
-    def get_category(self, category_id=""):
+    def get_category_list(self, category_id=""):
         if category_id:
         # api=SYNO.PhotoStation.Category&method=list&version=1&offset=0&limit=1000
-            data = "id=%s&api=SYNO.PhotoStation.Category&method=listitem&version=1&offset=0&limit=500&additional=album_permission,thumb_size" % category_id
+            data = "id=%s&api=SYNO.PhotoStation.Category&method=listitem&version=1&offset=0&limit=-1&additional=album_permission,photo_exif,video_codec,video_quality,thumb_size,file_location,item_count,album_sorting" % category_id
         else:
-            data = "api=SYNO.PhotoStation.Category&method=list&version=1&offset=0&limit=1000"
-        js = self._call2("category.php",data)
-        if js["success"] and "data" in js:
-            return js["data"]
-        else:
-            raise Exception("Error reading album info")
+            data = "api=SYNO.PhotoStation.Category&method=list&version=1&offset=0&limit=-1"
+        return self._call2("category.php",data)
 
     def get_smart_album(self, id=""):
         if id:
         else:
             #sort_by=title&sort_direction=desc&api=SYNO.PhotoStation.SmartAlbum&method=list&version=1&offset=0&limit=500&additional=thumb_size
             data = "sort_by=title&sort_direction=desc&api=SYNO.PhotoStation.SmartAlbum&method=list&version=1&offset=0&limit=500&additional=thumb_size"
-        js = self._call2("smart_album.php",data)
-        if js["success"] and "data" in js:
-            return js["data"]
-        else:
-            raise Exception("Error reading album info")
+        return self._call2("smart_album.php",data)
 
     def get_photo_info(self,id):
         data = "id=%s&version=1&api=SYNO.PhotoStation.Photo&method=getinfo&ps_username=%s&additional=album_permission,photo_exif,video_codec,video_quality,thumb_size,file_location,item_count,album_sorting"%(id,self.user)
         js = self._call2("photo.php",data)
-        if js["success"] and "data" in js:
-            return js["data"][0]
+        if isinstance(js, list):
+            return js[0]
         else:
-            raise Exception("Error reading photo/video info")
+            return js
 
     def get_thumb(self,id,size="peview",rotate=0 ):
         # siz = preview|small|large
         return content
 
     def get_thumb_url(self,id,size="small",rotate=0 ):
+        # small (M),preview (PREVIEW),large (XL)
         # http://home.blue.lv/photo/webapi/thumb.php?api=SYNO.PhotoStation.Thumb&method=get&version=1&size=large&id=photo_323031372f323031372d30312d787820537475626169_53353032303031372e4a5047&rotate_version=0&thumb_sig=&PHPSESSID=p51g2ssj3b2o3legsoqfqdc8r3
         url = "%sthumb.php?api=SYNO.PhotoStation.Thumb&method=get&version=1&size=%s&id=%s&rotate_version=%s&thumb_sig=&PHPSESSID=%s"%(
                 self.url, size, id, rotate, self.sid )
         return url
 
+    def get_photo_url(self,id):
+        url = "%sdownload.php?api=SYNO.PhotoStation.Download&method=getphoto&version=1&id=%s&PHPSESSID=%s" % (
+                self.url, id, self.sid )
+        return url
+
+
+    def get_video_url(self,id, quality_id=""):
+        if not quality_id:
+            url = "%sdownload.php?api=SYNO.PhotoStation.Download&method=getvideo&version=1&id=%s&PHPSESSID=%s" % (
+                self.url, id, self.sid )
+        else:
+            url = "%sdownload.php?api=SYNO.PhotoStation.Download&method=getvideo&version=1&id=%s&quality_id=%s&PHPSESSID=%s" % (
+                self.url, id, quality_id, self.sid )
+        return url
+
+
     def get_video_streams(self,id):
         urls = []
         js = self.get_photo_info(id)
         try:
             r = requests.post(url,data,headers=self.headers)
             js = json.loads(r.content)
-            return js
         except Exception as e:
-            return {}
+            raise Exception(e)
+        if not (js["success"] and "data" in js):
+            raise Exception("PhotoStation API %s error %s\n%s" % ( path, js["error"]["code"], data))
+        else:
+            return js["data"]
 
     def _call2(self,path,data):
         "GET request to PhotoStation API"
             print url
             r = requests.get(url,headers=self.headers)
             js = json.loads(r.content)
-            return js
         except Exception as e:
-            return {}
+            raise Exception(e)
+        if not (js["success"] and "data" in js):
+            raise Exception("PhotoStation API %s error %s\n%s" % ( path, js["error"]["code"], data))
+        else:
+            return js["data"]
+
 
     def _check_url(self,url):
         if self.sid:
         else:
             return True
 
+    def call_api(self, obj, method, **kwargs):
+        proc = "SYNO.PhotoStation." + obj
+        if proc not in self.api:
+            raise Exception("Not valid API object name ", obj)
+        path = self.api[proc]["path"]
+        data = {}
+        data["api"] = proc
+        data["method"] = method
+        data["version"] = 1
+        data.update(kwargs)
+        return self._call2(path, data)
+
+API = {
+    "SYNO.PhotoStation.Auth": {
+        "path": "auth.php",
+        "methods": {
+            "1": ["login", "logout", "checkauth"]
+        }
+    },
+    "SYNO.PhotoStation.Info": {
+        "path": "info.php",
+        "methods": {
+            "1": ["getinfo"]
+        }
+    },
+    "SYNO.PhotoStation.Album": {
+        "path": "album.php",
+        "methods": {
+            "1": ["list", "getinfo", "create", "edit", "delete", "arrangeitem", "move", "cleararrangeitem", "cancel"]
+        }
+    },
+    "SYNO.PhotoStation.Permission": {
+        "path": "permission.php",
+        "methods": {
+            "1": ["getalbum", "editalbum", "editgroup", "list_public_share", "edit_public_share"]
+        }
+    },
+    "SYNO.PhotoStation.Photo": {
+        "path": "photo.php",
+        "methods": {
+            "1": ["list", "listexif", "listfeatureditem", "listgpsgroup", "listgpsgroupeditem", "getinfo", "getexif", "edit", "delete", "copy", "cancel"]
+        }
+    },
+    "SYNO.PhotoStation.Thumb": {
+        "path": "thumb.php",
+        "methods": {
+            "1": ["get", "get_dsm_thumb"]
+        }
+    },
+    "SYNO.PhotoStation.Cover": {
+        "path": "cover.php",
+        "methods": {
+            "1": ["set"]
+        }
+    },
+    "SYNO.PhotoStation.SmartAlbum": {
+        "path": "smart_album.php",
+        "methods": {
+            "1": ["list", "getinfo", "create", "edit", "delete"]
+        }
+    },
+    "SYNO.PhotoStation.File": {
+        "path": "file.php",
+        "methods": {
+            "1": ["uploadphoto", "uploadvideo"]
+        }
+    },
+    "SYNO.PhotoStation.Download": {
+        "path": "download.php",
+        "methods": {
+            "1": ["getphoto", "getvideo", "getitem"]
+        }
+    },
+    "SYNO.PhotoStation.ory": {
+        "path": "ory.php",
+        "methods": {
+            "1": ["list", "getinfo", "create", "edit", "delete", "arrangeory", "listitem", "additem", "removeitem", "arrangeitem"]
+        }
+    },
+    "SYNO.PhotoStation.About": {
+        "path": "about.php",
+        "methods": {
+            "1": ["get", "set", "set_visibility"]
+        }
+    },
+    "SYNO.PhotoStation.Tag": {
+        "path": "tag.php",
+        "methods": {
+            "1": ["list", "getinfo", "create", "edit", "delete", "searchplace", "delete_unconfirmed_tag"]
+        }
+    },
+    "SYNO.PhotoStation.PhotoTag": {
+        "path": "photo_tag.php",
+        "methods": {
+            "1": ["list", "people_tag", "geo_tag", "desc_tag", "delete", "people_tag_confirm"]
+        }
+    },
+    "SYNO.PhotoStation.Comment": {
+        "path": "comment.php",
+        "methods": {
+            "1": ["list", "create", "delete"]
+        }
+    },
+    "SYNO.PhotoStation.Timeline": {
+        "path": "timeline.php",
+        "methods": {
+            "1": ["getindex"]
+        }
+    },
+    "SYNO.PhotoStation.Group": {
+        "path": "group.php",
+        "methods": {
+            "1": ["list", "get", "get_dsm_group", "getmember", "create", "edit", "editmember", "delete"]
+        }
+    },
+    "SYNO.PhotoStation.Rotate": {
+        "path": "rotate.php",
+        "methods": {
+            "1": ["set"]
+        }
+    },
+    "SYNO.PhotoStation.SlideshowMusic": {
+        "path": "slideshow_music.php",
+        "methods": {
+            "1": ["list", "get", "add", "edit", "delete"]
+        }
+    },
+    "SYNO.PhotoStation.DsmShare": {
+        "path": "dsm_share.php",
+        "methods": {
+            "1": ["list", "copy", "copymusic"]
+        }
+    },
+    "SYNO.PhotoStation.SharedAlbum": {
+        "path": "shared_album.php",
+        "methods": {
+            "1": ["list", "getinfo", "getinfo_public", "create", "edit", "delete", "add_items", "remove_items", "edit_public_share", "get_single_item", "set_single_item"]
+        }
+    },
+    "SYNO.PhotoStation.PhotoLog": {
+        "path": "log.php",
+        "methods": {
+            "1": ["list", "clear", "export"]
+        }
+    },
+    "SYNO.PhotoStation.Path": {
+        "path": "path.php",
+        "methods": {
+            "1": ["	", "checkpath"]
+        }
+    }
+}
 
 if __name__ == "__main__":
     ps = PhotoStationAPI("http://home.blue.lv/photo")
     print ps.login("user","Kaskade7")
 
-    js = ps.get_category("category_1")
+    js = ps.call_api("Category", "list", offset=0, limit=120)
+    js = ps.get_category_list("category_1")
+
+
+    #js = ps.get_category("category_1")
+    video_id = "video_323031372f323031372d31322d3234205a69656d6173737665746b692f636c697073_30303133332e4d5453"
+    quality_id = "2f766f6c756d65312f70686f746f2f323031372f323031372d31322d3234205a69656d6173737665746b692f636c6970732f4065614469722f30303133332e4d54532f53594e4f50484f544f5f46494c4d5f4d2e6d7034"
+    url = ps.get_video_url(video_id, quality_id)
+    url0 =  ps.get_video_url(video_id, "")
+
+
     album_id = u'album_323031372f323031372d30312d313320536c69646f73616e61'
     js = ps.get_album_info(album_id)
-    js = ps.get_album_list2(album_id)
+    js = ps.get_album_list(album_id)
+    album_id = "album_323031372f323031372d30312d313320536c69646f73616e612f766964656f"
+    js = ps.get_album_list(album_id)
 
     photo_id = "photo_323031372f323031372d30312d787820537475626169_53353032303031372e4a5047"
     js = ps.get_photo_info(photo_id)

resources/settings.xml

         <setting label="50010" id="start_page" type="select" default="Albums" values="Albums|Categories|category_1|category_2|category_3" />
         <setting label="50003" id="sorting" type="select" default="preference" values="preference|filename|takendate|createdate" />
         <setting label="50004" id="order" type="select" default="asc" values="asc|desc" />
-        <setting label="50005" id="video_quality" type="select" default="low" values="low|high" />
-        <setting label="50006" id="picture_quality" type="select" default="original" values="low|high|original" />
-        <setting label="50007" id="interval" type="number" default="3" />
+        <setting label="50011" id="play_next" type="bool" default="true" />
+        <setting label="50005" id="video_quality" type="select" default="low" values="medium|original" />
+        <setting label="50006" id="picture_quality" type="select" default="original" values="preview|large|original" />
+        <setting label="50012" id="thumbnail_quality" type="select" default="small" values="preview|small|large" />
         <setting label="50008" id="repeat" type="bool" default="false" />
         <setting label="50009" id="random" type="bool" default="false" />
         <setting type="sep" />