resources/lib/KodiHelper.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 # Module: KodiHelper
   4 # Created on: 13.01.2017
   5
   6 import xbmcplugin
   7 import xbmcgui
   8 import xbmc
   9 import json
  10 from os.path import join
  11 from urllib import urlencode
  12 from xbmcaddon import Addon
  13 from uuid import uuid4
  14 from UniversalAnalytics import Tracker
  15 try:
  16    import cPickle as pickle
  17 except:
  18    import pickle
  19
  20 class KodiHelper:
  21     """Consumes all the configuration data from Kodi as well as turns data into lists of folders and videos"""
  22
  23     def __init__ (self, plugin_handle=None, base_url=None):
  24         """Fetches all needed info from Kodi & configures the baseline of the plugin
  25
  26         Parameters
  27         ----------
  28         plugin_handle : :obj:`int`
  29             Plugin handle
  30
  31         base_url : :obj:`str`
  32             Plugin base url
  33         """
  34         self.plugin_handle = plugin_handle
  35         self.base_url = base_url
  36         self.addon = Addon()
  37         self.plugin = self.addon.getAddonInfo('name')
  38         self.base_data_path = xbmc.translatePath(self.addon.getAddonInfo('profile'))
  39         self.home_path = xbmc.translatePath('special://home')
  40         self.plugin_path = self.addon.getAddonInfo('path')
  41         self.cookie_path = self.base_data_path + 'COOKIE'
  42         self.data_path = self.base_data_path + 'DATA'
  43         self.config_path = join(self.base_data_path, 'config')
  44         self.msl_data_path = xbmc.translatePath('special://profile/addon_data/service.msl').decode('utf-8') + '/'
  45         self.verb_log = self.addon.getSetting('logging') == 'true'
  46         self.default_fanart = self.addon.getAddonInfo('fanart')
  47         self.library = None
  48         self.setup_memcache()
  49
  50     def refresh (self):
  51         """Refresh the current list"""
  52         return xbmc.executebuiltin('Container.Refresh')
  53
  54     def show_rating_dialog (self):
  55         """Asks the user for a movie rating
  56
  57         Returns
  58         -------
  59         :obj:`int`
  60             Movie rating between 0 & 10
  61         """
  62         dlg = xbmcgui.Dialog()
  63         return dlg.numeric(heading=self.get_local_string(string_id=30019) + ' ' + self.get_local_string(string_id=30022), type=0)
  64
  65     def show_search_term_dialog (self):
  66         """Asks the user for a term to query the netflix search for
  67
  68         Returns
  69         -------
  70         :obj:`str`
  71             Term to search for
  72         """
  73         dlg = xbmcgui.Dialog()
  74         term = dlg.input(self.get_local_string(string_id=30003), type=xbmcgui.INPUT_ALPHANUM)
  75         if len(term) == 0:
  76             term = ' '
  77         return term
  78
  79     def show_add_to_library_title_dialog (self, original_title):
  80         """Asks the user for an alternative title for the show/movie that gets exported to the local library
  81
  82         Parameters
  83         ----------
  84         original_title : :obj:`str`
  85             Original title of the show (as suggested by the addon)
  86
  87         Returns
  88         -------
  89         :obj:`str`
  90             Title to persist
  91         """
  92         dlg = xbmcgui.Dialog()
  93         return dlg.input(heading=self.get_local_string(string_id=30031), defaultt=original_title, type=xbmcgui.INPUT_ALPHANUM)
  94
  95     def show_password_dialog (self):
  96         """Asks the user for its Netflix password
  97
  98         Returns
  99         -------
 100         :obj:`str`
 101             Netflix password
 102         """
 103         dlg = xbmcgui.Dialog()
 104         return dlg.input(self.get_local_string(string_id=30004), type=xbmcgui.INPUT_ALPHANUM, option=xbmcgui.ALPHANUM_HIDE_INPUT)
 105
 106     def show_email_dialog (self):
 107         """Asks the user for its Netflix account email
 108
 109         Returns
 110         -------
 111         term : :obj:`str`
 112             Netflix account email
 113         """
 114         dlg = xbmcgui.Dialog()
 115         return dlg.input(self.get_local_string(string_id=30005), type=xbmcgui.INPUT_ALPHANUM)
 116
 117     def show_login_failed_notification (self):
 118         """Shows notification that the login failed
 119
 120         Returns
 121         -------
 122         bool
 123             Dialog shown
 124         """
 125         dialog = xbmcgui.Dialog()
 126         dialog.notification(self.get_local_string(string_id=30008), self.get_local_string(string_id=30009), xbmcgui.NOTIFICATION_ERROR, 5000)
 127         return True
 128
 129     def show_missing_inputstream_addon_notification (self):
 130         """Shows notification that the inputstream addon couldn't be found
 131
 132         Returns
 133         -------
 134         bool
 135             Dialog shown
 136         """
 137         dialog = xbmcgui.Dialog()
 138         dialog.notification(self.get_local_string(string_id=30028), self.get_local_string(string_id=30029), xbmcgui.NOTIFICATION_ERROR, 5000)
 139         return True
 140
 141     def show_no_search_results_notification (self):
 142         """Shows notification that no search results could be found
 143
 144         Returns
 145         -------
 146         bool
 147             Dialog shown
 148         """
 149         dialog = xbmcgui.Dialog()
 150         dialog.notification(self.get_local_string(string_id=30011), self.get_local_string(string_id=30013))
 151         return True
 152
 153     def show_no_seasons_notification (self):
 154         """Shows notification that no seasons be found
 155
 156         Returns
 157         -------
 158         bool
 159             Dialog shown
 160         """
 161         dialog = xbmcgui.Dialog()
 162         dialog.notification(self.get_local_string(string_id=30010), self.get_local_string(string_id=30012))
 163         return True
 164
 165     def set_setting (self, key, value):
 166         """Public interface for the addons setSetting method
 167
 168         Returns
 169         -------
 170         bool
 171             Setting could be set or not
 172         """
 173         return self.addon.setSetting(key, value)
 174
 175     def get_credentials (self):
 176         """Returns the users stored credentials
 177
 178         Returns
 179         -------
 180         :obj:`dict` of :obj:`str`
 181             The users stored account data
 182         """
 183         return {
 184             'email': self.addon.getSetting('email'),
 185             'password': self.addon.getSetting('password')
 186         }
 187
 188     def get_dolby_setting(self):
 189         """
 190         Returns if the dolby sound is enabled
 191         :return: True|False
 192         """
 193         return self.addon.getSetting('enable_dolby_sound') == 'true'
 194
 195     def get_custom_library_settings (self):
 196         """Returns the settings in regards to the custom library folder(s)
 197
 198         Returns
 199         -------
 200         :obj:`dict` of :obj:`str`
 201             The users library settings
 202         """
 203         return {
 204             'enablelibraryfolder': self.addon.getSetting('enablelibraryfolder'),
 205             'customlibraryfolder': self.addon.getSetting('customlibraryfolder')
 206         }
 207
 208     def get_ssl_verification_setting (self):
 209         """Returns the setting that describes if we should verify the ssl transport when loading data
 210
 211         Returns
 212         -------
 213         bool
 214             Verify or not
 215         """
 216         return self.addon.getSetting('ssl_verification') == 'true'
 217
 218     def set_main_menu_selection (self, type):
 219         """Persist the chosen main menu entry in memory
 220
 221         Parameters
 222         ----------
 223         type : :obj:`str`
 224             Selected menu item
 225         """
 226         xbmcgui.Window(xbmcgui.getCurrentWindowId()).setProperty('main_menu_selection', type)
 227
 228     def get_main_menu_selection (self):
 229         """Gets the persisted chosen main menu entry from memory
 230
 231         Returns
 232         -------
 233         :obj:`str`
 234             The last chosen main menu entry
 235         """
 236         return xbmcgui.Window(xbmcgui.getCurrentWindowId()).getProperty('main_menu_selection')
 237
 238     def setup_memcache (self):
 239         """Sets up the memory cache if not existant"""
 240         cached_items = xbmcgui.Window(xbmcgui.getCurrentWindowId()).getProperty('memcache')
 241         # no cache setup yet, create one
 242         if len(cached_items) < 1:
 243             xbmcgui.Window(xbmcgui.getCurrentWindowId()).setProperty('memcache', pickle.dumps({}))
 244
 245     def invalidate_memcache (self):
 246         """Invalidates the memory cache"""
 247         xbmcgui.Window(xbmcgui.getCurrentWindowId()).setProperty('memcache', pickle.dumps({}))
 248
 249     def has_cached_item (self, cache_id):
 250         """Checks if the requested item is in memory cache
 251
 252         Parameters
 253         ----------
 254         cache_id : :obj:`str`
 255             ID of the cache entry
 256
 257         Returns
 258         -------
 259         bool
 260             Item is cached
 261         """
 262         cached_items = pickle.loads(xbmcgui.Window(xbmcgui.getCurrentWindowId()).getProperty('memcache'))
 263         return cache_id in cached_items.keys()
 264
 265     def get_cached_item (self, cache_id):
 266         """Returns an item from the in memory cache
 267
 268         Parameters
 269         ----------
 270         cache_id : :obj:`str`
 271             ID of the cache entry
 272
 273         Returns
 274         -------
 275         mixed
 276             Contents of the requested cache item or none
 277         """
 278         cached_items = pickle.loads(xbmcgui.Window(xbmcgui.getCurrentWindowId()).getProperty('memcache'))
 279         if self.has_cached_item(cache_id) != True:
 280             return None
 281         return cached_items[cache_id]
 282
 283     def add_cached_item (self, cache_id, contents):
 284         """Adds an item to the in memory cache
 285
 286         Parameters
 287         ----------
 288         cache_id : :obj:`str`
 289             ID of the cache entry
 290
 291         contents : mixed
 292             Cache entry contents
 293         """
 294         cached_items = pickle.loads(xbmcgui.Window(xbmcgui.getCurrentWindowId()).getProperty('memcache'))
 295         cached_items.update({cache_id: contents})
 296         xbmcgui.Window(xbmcgui.getCurrentWindowId()).setProperty('memcache', pickle.dumps(cached_items))
 297
 298     def build_profiles_listing (self, profiles, action, build_url):
 299         """Builds the profiles list Kodi screen
 300
 301         Parameters
 302         ----------
 303         profiles : :obj:`dict` of :obj:`str`
 304             List of user profiles
 305
 306         action : :obj:`str`
 307             Action paramter to build the subsequent routes
 308
 309         build_url : :obj:`fn`
 310             Function to build the subsequent routes
 311
 312         Returns
 313         -------
 314         bool
 315             List could be build
 316         """
 317         for profile_id in profiles:
 318             profile = profiles[profile_id]
 319             url = build_url({'action': action, 'profile_id': profile_id})
 320             li = xbmcgui.ListItem(label=profile['profileName'], iconImage=profile['avatar'])
 321             li.setProperty('fanart_image', self.default_fanart)
 322             xbmcplugin.addDirectoryItem(handle=self.plugin_handle, url=url, listitem=li, isFolder=True)
 323             xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_LABEL)
 324         xbmcplugin.endOfDirectory(self.plugin_handle)
 325         return True
 326
 327     def build_main_menu_listing (self, video_list_ids, user_list_order, actions, build_url):
 328         """Builds the video lists (my list, continue watching, etc.) Kodi screen
 329
 330         Parameters
 331         ----------
 332         video_list_ids : :obj:`dict` of :obj:`str`
 333             List of video lists
 334
 335         user_list_order : :obj:`list` of :obj:`str`
 336             Ordered user lists, to determine what should be displayed in the main menue
 337
 338         actions : :obj:`dict` of :obj:`str`
 339             Dictionary of actions to build subsequent routes
 340
 341         build_url : :obj:`fn`
 342             Function to build the subsequent routes
 343
 344         Returns
 345         -------
 346         bool
 347             List could be build
 348         """
 349         preselect_items = []
 350         for category in user_list_order:
 351             for video_list_id in video_list_ids['user']:
 352                 if video_list_ids['user'][video_list_id]['name'] == category:
 353                     label = video_list_ids['user'][video_list_id]['displayName']
 354                     if category == 'netflixOriginals':
 355                         label = label.capitalize()
 356                     li = xbmcgui.ListItem(label=label)
 357                     li.setProperty('fanart_image', self.default_fanart)
 358                     # determine action route
 359                     action = actions['default']
 360                     if category in actions.keys():
 361                         action = actions[category]
 362                     # determine if the item should be selected
 363                     preselect_items.append((False, True)[category == self.get_main_menu_selection()])
 364                     url = build_url({'action': action, 'video_list_id': video_list_id, 'type': category})
 365                     xbmcplugin.addDirectoryItem(handle=self.plugin_handle, url=url, listitem=li, isFolder=True)
 366
 367         # add recommendations/genres as subfolders (save us some space on the home page)
 368         i18n_ids = {
 369             'recommendations': self.get_local_string(30001),
 370             'genres': self.get_local_string(30010)
 371         }
 372         for type in i18n_ids.keys():
 373             # determine if the lists have contents
 374             if len(video_list_ids[type]) > 0:
 375                 # determine action route
 376                 action = actions['default']
 377                 if type in actions.keys():
 378                     action = actions[type]
 379                 # determine if the item should be selected
 380                 preselect_items.append((False, True)[type == self.get_main_menu_selection()])
 381                 li_rec = xbmcgui.ListItem(label=i18n_ids[type])
 382                 li_rec.setProperty('fanart_image', self.default_fanart)
 383                 url_rec = build_url({'action': action, 'type': type})
 384                 xbmcplugin.addDirectoryItem(handle=self.plugin_handle, url=url_rec, listitem=li_rec, isFolder=True)
 385
 386         # add search as subfolder
 387         action = actions['default']
 388         if 'search' in actions.keys():
 389             action = actions[type]
 390         li_rec = xbmcgui.ListItem(label=self.get_local_string(30011))
 391         li_rec.setProperty('fanart_image', self.default_fanart)
 392         url_rec = build_url({'action': action, 'type': 'search'})
 393         xbmcplugin.addDirectoryItem(handle=self.plugin_handle, url=url_rec, listitem=li_rec, isFolder=True)
 394
 395         # no srting & close
 396         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_UNSORTED)
 397         xbmcplugin.endOfDirectory(self.plugin_handle)
 398
 399         # (re)select the previously selected main menu entry
 400         idx = 1
 401         for item in preselect_items:
 402             idx += 1
 403             preselected_list_item = idx if item else None
 404         preselected_list_item = idx + 1 if self.get_main_menu_selection() == 'search' else preselected_list_item
 405         if preselected_list_item != None:
 406             xbmc.executebuiltin('ActivateWindowAndFocus(%s, %s)' % (str(xbmcgui.Window(xbmcgui.getCurrentWindowId()).getFocusId()), str(preselected_list_item)))
 407         return True
 408
 409     def build_video_listing (self, video_list, actions, type, build_url):
 410         """Builds the video lists (my list, continue watching, etc.) contents Kodi screen
 411
 412         Parameters
 413         ----------
 414         video_list_ids : :obj:`dict` of :obj:`str`
 415             List of video lists
 416
 417         actions : :obj:`dict` of :obj:`str`
 418             Dictionary of actions to build subsequent routes
 419
 420         type : :obj:`str`
 421             None or 'queue' f.e. when it´s a special video lists
 422
 423         build_url : :obj:`fn`
 424             Function to build the subsequent routes
 425
 426         Returns
 427         -------
 428         bool
 429             List could be build
 430         """
 431         for video_list_id in video_list:
 432             video = video_list[video_list_id]
 433             if type != 'queue' or (type == 'queue' and video['in_my_list'] == True):
 434                 li = xbmcgui.ListItem(label=video['title'])
 435                 # add some art to the item
 436                 li = self._generate_art_info(entry=video, li=li)
 437                 # it´s a show, so we need a subfolder & route (for seasons)
 438                 isFolder = True
 439                 url = build_url({'action': actions[video['type']], 'show_id': video_list_id})
 440                 # lists can be mixed with shows & movies, therefor we need to check if its a movie, so play it right away
 441                 if video_list[video_list_id]['type'] == 'movie':
 442                     # it´s a movie, so we need no subfolder & a route to play it
 443                     isFolder = False
 444                     url = build_url({'action': 'play_video', 'video_id': video_list_id})
 445                 # add list item info
 446                 li = self._generate_entry_info(entry=video, li=li)
 447                 li = self._generate_context_menu_items(entry=video, li=li)
 448                 xbmcplugin.addDirectoryItem(handle=self.plugin_handle, url=url, listitem=li, isFolder=isFolder)
 449
 450         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_LABEL)
 451         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_TITLE)
 452         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_VIDEO_YEAR)
 453         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_GENRE)
 454         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_LASTPLAYED)
 455         xbmcplugin.endOfDirectory(self.plugin_handle)
 456         return True
 457
 458     def build_search_result_listing (self, video_list, actions, build_url):
 459         """Builds the search results list Kodi screen
 460
 461         Parameters
 462         ----------
 463         video_list : :obj:`dict` of :obj:`str`
 464             List of videos or shows
 465
 466         actions : :obj:`dict` of :obj:`str`
 467             Dictionary of actions to build subsequent routes
 468
 469         build_url : :obj:`fn`
 470             Function to build the subsequent routes
 471
 472         Returns
 473         -------
 474         bool
 475             List could be build
 476         """
 477         return self.build_video_listing(video_list=video_list, actions=actions, type='search', build_url=build_url)
 478
 479     def build_no_seasons_available (self):
 480         """Builds the season list screen if no seasons could be found
 481
 482         Returns
 483         -------
 484         bool
 485             List could be build
 486         """
 487         self.show_no_seasons_notification()
 488         xbmcplugin.endOfDirectory(self.plugin_handle)
 489         return True
 490
 491     def build_no_search_results_available (self, build_url, action):
 492         """Builds the search results screen if no matches could be found
 493
 494         Parameters
 495         ----------
 496         action : :obj:`str`
 497             Action paramter to build the subsequent routes
 498
 499         build_url : :obj:`fn`
 500             Function to build the subsequent routes
 501
 502         Returns
 503         -------
 504         bool
 505             List could be build
 506         """
 507         self.show_no_search_results_notification()
 508         return xbmcplugin.endOfDirectory(self.plugin_handle)
 509
 510     def build_user_sub_listing (self, video_list_ids, type, action, build_url):
 511         """Builds the video lists screen for user subfolders (genres & recommendations)
 512
 513         Parameters
 514         ----------
 515         video_list_ids : :obj:`dict` of :obj:`str`
 516             List of video lists
 517
 518         type : :obj:`str`
 519             List type (genre or recommendation)
 520
 521         action : :obj:`str`
 522             Action paramter to build the subsequent routes
 523
 524         build_url : :obj:`fn`
 525             Function to build the subsequent routes
 526
 527         Returns
 528         -------
 529         bool
 530             List could be build
 531         """
 532         for video_list_id in video_list_ids:
 533             li = xbmcgui.ListItem(video_list_ids[video_list_id]['displayName'])
 534             li.setProperty('fanart_image', self.default_fanart)
 535             url = build_url({'action': action, 'video_list_id': video_list_id})
 536             xbmcplugin.addDirectoryItem(handle=self.plugin_handle, url=url, listitem=li, isFolder=True)
 537
 538         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_LABEL)
 539         xbmcplugin.endOfDirectory(self.plugin_handle)
 540         return True
 541
 542     def build_season_listing (self, seasons_sorted, season_list, build_url):
 543         """Builds the season list screen for a show
 544
 545         Parameters
 546         ----------
 547         seasons_sorted : :obj:`list` of :obj:`str`
 548             Sorted season indexes
 549
 550         season_list : :obj:`dict` of :obj:`str`
 551             List of season entries
 552
 553         build_url : :obj:`fn`
 554             Function to build the subsequent routes
 555
 556         Returns
 557         -------
 558         bool
 559             List could be build
 560         """
 561         for index in seasons_sorted:
 562             for season_id in season_list:
 563                 season = season_list[season_id]
 564                 if int(season['idx']) == index:
 565                     li = xbmcgui.ListItem(label=season['text'])
 566                     # add some art to the item
 567                     li = self._generate_art_info(entry=season, li=li)
 568                     # add list item info
 569                     li = self._generate_entry_info(entry=season, li=li, base_info={'mediatype': 'season'})
 570                     li = self._generate_context_menu_items(entry=season, li=li)
 571                     url = build_url({'action': 'episode_list', 'season_id': season_id})
 572                     xbmcplugin.addDirectoryItem(handle=self.plugin_handle, url=url, listitem=li, isFolder=True)
 573
 574         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_NONE)
 575         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_VIDEO_YEAR)
 576         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_LABEL)
 577         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_LASTPLAYED)
 578         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_TITLE)
 579         xbmcplugin.endOfDirectory(self.plugin_handle)
 580         return True
 581
 582     def build_episode_listing (self, episodes_sorted, episode_list, build_url):
 583         """Builds the episode list screen for a season of a show
 584
 585         Parameters
 586         ----------
 587         episodes_sorted : :obj:`list` of :obj:`str`
 588             Sorted episode indexes
 589
 590         episode_list : :obj:`dict` of :obj:`str`
 591             List of episode entries
 592
 593         build_url : :obj:`fn`
 594             Function to build the subsequent routes
 595
 596         Returns
 597         -------
 598         bool
 599             List could be build
 600         """
 601         for index in episodes_sorted:
 602             for episode_id in episode_list:
 603                 episode = episode_list[episode_id]
 604                 if int(episode['episode']) == index:
 605                     li = xbmcgui.ListItem(label=episode['title'])
 606                     # add some art to the item
 607                     li = self._generate_art_info(entry=episode, li=li)
 608                     # add list item info
 609                     li = self._generate_entry_info(entry=episode, li=li, base_info={'mediatype': 'episode'})
 610                     li = self._generate_context_menu_items(entry=episode, li=li)
 611                     url = build_url({'action': 'play_video', 'video_id': episode_id, 'start_offset': episode['bookmark']})
 612                     xbmcplugin.addDirectoryItem(handle=self.plugin_handle, url=url, listitem=li, isFolder=False)
 613
 614         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_EPISODE)
 615         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_NONE)
 616         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_VIDEO_YEAR)
 617         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_LABEL)
 618         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_LASTPLAYED)
 619         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_TITLE)
 620         xbmcplugin.addSortMethod(handle=self.plugin_handle, sortMethod=xbmcplugin.SORT_METHOD_DURATION)
 621         xbmcplugin.endOfDirectory(self.plugin_handle)
 622         return True
 623
 624     def play_item (self, esn, video_id, start_offset=-1):
 625         """Plays a video
 626
 627         Parameters
 628         ----------
 629         esn : :obj:`str`
 630             ESN needed for Widevine/Inputstream
 631
 632         video_id : :obj:`str`
 633             ID of the video that should be played
 634
 635         start_offset : :obj:`str`
 636             Offset to resume playback from (in seconds)
 637
 638         Returns
 639         -------
 640         bool
 641             List could be build
 642         """
 643         inputstream_addon = self.get_inputstream_addon()
 644         if inputstream_addon == None:
 645             self.show_missing_inputstream_addon_notification()
 646             self.log(msg='Inputstream addon not found')
 647             return False
 648
 649         # track play event
 650         self.track_event('playVideo')
 651
 652         # check esn in settings
 653         settings_esn = str(self.addon.getSetting('esn'))
 654         if len(settings_esn) == 0:
 655             self.addon.setSetting('esn', str(esn))
 656
 657         # inputstream addon properties
 658         msl_service_url = 'http://localhost:' + str(self.addon.getSetting('msl_service_port'))
 659         play_item = xbmcgui.ListItem(path=msl_service_url + '/manifest?id=' + video_id)
 660         play_item.setProperty(inputstream_addon + '.license_type', 'com.widevine.alpha')
 661         play_item.setProperty(inputstream_addon + '.manifest_type', 'mpd')
 662         play_item.setProperty(inputstream_addon + '.license_key', msl_service_url + '/license?id=' + video_id + '||b{SSM}!b{SID}|')
 663         play_item.setProperty(inputstream_addon + '.server_certificate', 'Cr0CCAMSEOVEukALwQ8307Y2+LVP+0MYh/HPkwUijgIwggEKAoIBAQDm875btoWUbGqQD8eAGuBlGY+Pxo8YF1LQR+Ex0pDONMet8EHslcZRBKNQ/09RZFTP0vrYimyYiBmk9GG+S0wB3CRITgweNE15cD33MQYyS3zpBd4z+sCJam2+jj1ZA4uijE2dxGC+gRBRnw9WoPyw7D8RuhGSJ95OEtzg3Ho+mEsxuE5xg9LM4+Zuro/9msz2bFgJUjQUVHo5j+k4qLWu4ObugFmc9DLIAohL58UR5k0XnvizulOHbMMxdzna9lwTw/4SALadEV/CZXBmswUtBgATDKNqjXwokohncpdsWSauH6vfS6FXwizQoZJ9TdjSGC60rUB2t+aYDm74cIuxAgMBAAE6EHRlc3QubmV0ZmxpeC5jb20SgAOE0y8yWw2Win6M2/bw7+aqVuQPwzS/YG5ySYvwCGQd0Dltr3hpik98WijUODUr6PxMn1ZYXOLo3eED6xYGM7Riza8XskRdCfF8xjj7L7/THPbixyn4mULsttSmWFhexzXnSeKqQHuoKmerqu0nu39iW3pcxDV/K7E6aaSr5ID0SCi7KRcL9BCUCz1g9c43sNj46BhMCWJSm0mx1XFDcoKZWhpj5FAgU4Q4e6f+S8eX39nf6D6SJRb4ap7Znzn7preIvmS93xWjm75I6UBVQGo6pn4qWNCgLYlGGCQCUm5tg566j+/g5jvYZkTJvbiZFwtjMW5njbSRwB3W4CrKoyxw4qsJNSaZRTKAvSjTKdqVDXV/U5HK7SaBA6iJ981/aforXbd2vZlRXO/2S+Maa2mHULzsD+S5l4/YGpSt7PnkCe25F+nAovtl/ogZgjMeEdFyd/9YMYjOS4krYmwp3yJ7m9ZzYCQ6I8RQN4x/yLlHG5RH/+WNLNUs6JAZ0fFdCmw=')
 664         play_item.setProperty('inputstreamaddon', inputstream_addon)
 665
 666         # check if we have a bookmark e.g. start offset position
 667         if int(start_offset) > 0:
 668             play_item.setProperty('StartOffset', str(start_offset) + '.0')
 669         return xbmcplugin.setResolvedUrl(self.plugin_handle, True, listitem=play_item)
 670
 671     def _generate_art_info (self, entry, li):
 672         """Adds the art info from an entry to a Kodi list item
 673
 674         Parameters
 675         ----------
 676         entry : :obj:`dict` of :obj:`str`
 677             Entry that should be turned into a list item
 678
 679         li : :obj:`XMBC.ListItem`
 680             Kodi list item instance
 681
 682         Returns
 683         -------
 684         :obj:`XMBC.ListItem`
 685             Kodi list item instance
 686         """
 687         art = {'fanart': self.default_fanart}
 688         if 'boxarts' in dict(entry).keys():
 689             art.update({
 690                 'poster': entry['boxarts']['big'],
 691                 'landscape': entry['boxarts']['big'],
 692                 'thumb': entry['boxarts']['small'],
 693                 'fanart': entry['boxarts']['big']
 694             })
 695         if 'interesting_moment' in dict(entry).keys():
 696             art.update({
 697                 'poster': entry['interesting_moment'],
 698                 'fanart': entry['interesting_moment']
 699             })
 700         if 'thumb' in dict(entry).keys():
 701             art.update({'thumb': entry['thumb']})
 702         if 'fanart' in dict(entry).keys():
 703             art.update({'fanart': entry['fanart']})
 704         if 'poster' in dict(entry).keys():
 705             art.update({'poster': entry['poster']})
 706         li.setArt(art)
 707         return li
 708
 709     def _generate_entry_info (self, entry, li, base_info={}):
 710         """Adds the item info from an entry to a Kodi list item
 711
 712         Parameters
 713         ----------
 714         entry : :obj:`dict` of :obj:`str`
 715             Entry that should be turned into a list item
 716
 717         li : :obj:`XMBC.ListItem`
 718             Kodi list item instance
 719
 720         base_info : :obj:`dict` of :obj:`str`
 721             Additional info that overrules the entry info
 722
 723         Returns
 724         -------
 725         :obj:`XMBC.ListItem`
 726             Kodi list item instance
 727         """
 728         infos = base_info
 729         entry_keys = entry.keys()
 730         if 'cast' in entry_keys and len(entry['cast']) > 0:
 731             infos.update({'cast': entry['cast']})
 732         if 'creators' in entry_keys and len(entry['creators']) > 0:
 733             infos.update({'writer': entry['creators'][0]})
 734         if 'directors' in entry_keys and len(entry['directors']) > 0:
 735             infos.update({'director': entry['directors'][0]})
 736         if 'genres' in entry_keys and len(entry['genres']) > 0:
 737             infos.update({'genre': entry['genres'][0]})
 738         if 'maturity' in entry_keys:
 739             if 'mpaa' in entry_keys:
 740                 infos.update({'mpaa': entry['mpaa']})
 741             else:
 742                 infos.update({'mpaa': str(entry['maturity']['board']) + '-' + str(entry['maturity']['value'])})
 743         if 'rating' in entry_keys:
 744             infos.update({'rating': int(entry['rating']) * 2})
 745         if 'synopsis' in entry_keys:
 746             infos.update({'plot': entry['synopsis']})
 747         if 'plot' in entry_keys:
 748             infos.update({'plot': entry['plot']})
 749         if 'runtime' in entry_keys:
 750             infos.update({'duration': entry['runtime']})
 751         if 'duration' in entry_keys:
 752             infos.update({'duration': entry['duration']})
 753         if 'seasons_label' in entry_keys:
 754             infos.update({'season': entry['seasons_label']})
 755         if 'season' in entry_keys:
 756             infos.update({'season': entry['season']})
 757         if 'title' in entry_keys:
 758             infos.update({'title': entry['title']})
 759         if 'type' in entry_keys:
 760             if entry['type'] == 'movie' or entry['type'] == 'episode':
 761                 li.setProperty('IsPlayable', 'true')
 762         if 'mediatype' in entry_keys:
 763             if entry['mediatype'] == 'movie' or entry['mediatype'] == 'episode':
 764                 li.setProperty('IsPlayable', 'true')
 765                 infos.update({'mediatype': entry['mediatype']})
 766         if 'watched' in entry_keys:
 767             infos.update({'playcount': (1, 0)[entry['watched']]})
 768         if 'index' in entry_keys:
 769             infos.update({'episode': entry['index']})
 770         if 'episode' in entry_keys:
 771             infos.update({'episode': entry['episode']})
 772         if 'year' in entry_keys:
 773             infos.update({'year': entry['year']})
 774         if 'quality' in entry_keys:
 775             quality = {'width': '960', 'height': '540'}
 776             if entry['quality'] == '720':
 777                 quality = {'width': '1280', 'height': '720'}
 778             if entry['quality'] == '1080':
 779                 quality = {'width': '1920', 'height': '1080'}
 780             li.addStreamInfo('video', quality)
 781         li.setInfo('video', infos)
 782         return li
 783
 784     def _generate_context_menu_items (self, entry, li):
 785         """Adds context menue items to a Kodi list item
 786
 787         Parameters
 788         ----------
 789         entry : :obj:`dict` of :obj:`str`
 790             Entry that should be turned into a list item
 791
 792         li : :obj:`XMBC.ListItem`
 793             Kodi list item instance
 794         Returns
 795         -------
 796         :obj:`XMBC.ListItem`
 797             Kodi list item instance
 798         """
 799         items = []
 800         action = {}
 801         entry_keys = entry.keys()
 802
 803         # action item templates
 804         encoded_title = urlencode({'title': entry['title'].encode('utf-8')}) if 'title' in entry else ''
 805         url_tmpl = 'XBMC.RunPlugin(' + self.base_url + '?action=%action%&id=' + str(entry['id']) + '&' + encoded_title + ')'
 806         actions = [
 807             ['export_to_library', self.get_local_string(30018), 'export'],
 808             ['remove_from_library', self.get_local_string(30030), 'remove'],
 809             ['rate_on_netflix', self.get_local_string(30019), 'rating'],
 810             ['remove_from_my_list', self.get_local_string(30020), 'remove_from_list'],
 811             ['add_to_my_list', self.get_local_string(30021), 'add_to_list']
 812         ]
 813
 814         # build concrete action items
 815         for action_item in actions:
 816             action.update({action_item[0]: [action_item[1], url_tmpl.replace('%action%', action_item[2])]})
 817
 818         # add or remove the movie/show/season/episode from & to the users "My List"
 819         if 'in_my_list' in entry_keys:
 820             items.append(action['remove_from_my_list']) if entry['in_my_list'] else items.append(action['add_to_my_list'])
 821         elif 'queue' in entry_keys:
 822             items.append(action['remove_from_my_list']) if entry['queue'] else items.append(action['add_to_my_list'])
 823         elif 'my_list' in entry_keys:
 824             items.append(action['remove_from_my_list']) if entry['my_list'] else items.append(action['add_to_my_list'])
 825         # rate the movie/show/season/episode on Netflix
 826         items.append(action['rate_on_netflix'])
 827
 828         # add possibility to export this movie/show/season/episode to a static/local library (and to remove it)
 829         if 'type' in entry_keys:
 830             # add/remove movie
 831             if entry['type'] == 'movie':
 832                 action_type = 'remove_from_library' if self.library.movie_exists(title=entry['title'], year=entry['year']) else 'export_to_library'
 833                 items.append(action[action_type])
 834             # add/remove show
 835             if entry['type'] == 'show' and 'title' in entry_keys:
 836                 action_type = 'remove_from_library' if self.library.show_exists(title=entry['title']) else 'export_to_library'
 837                 items.append(action[action_type])
 838
 839         # add it to the item
 840         li.addContextMenuItems(items)
 841         return li
 842
 843     def log (self, msg, level=xbmc.LOGDEBUG):
 844         """Adds a log entry to the Kodi log
 845
 846         Parameters
 847         ----------
 848         msg : :obj:`str`
 849             Entry that should be turned into a list item
 850
 851         level : :obj:`int`
 852             Kodi log level
 853         """
 854         if isinstance(msg, unicode):
 855             msg = msg.encode('utf-8')
 856         xbmc.log('[%s] %s' % (self.plugin, msg.__str__()), level)
 857
 858     def get_local_string (self, string_id):
 859         """Returns the localized version of a string
 860
 861         Parameters
 862         ----------
 863         string_id : :obj:`int`
 864             ID of the string that shoudl be fetched
 865
 866         Returns
 867         -------
 868         :obj:`str`
 869             Requested string or empty string
 870         """
 871         src = xbmc if string_id < 30000 else self.addon
 872         locString = src.getLocalizedString(string_id)
 873         if isinstance(locString, unicode):
 874             locString = locString.encode('utf-8')
 875         return locString
 876
 877     def get_inputstream_addon (self):
 878         """Checks if the inputstream addon is installed & enabled.
 879            Returns the type of the inputstream addon used or None if not found
 880
 881         Returns
 882         -------
 883         :obj:`str` or None
 884             Inputstream addon or None
 885         """
 886         type = 'inputstream.adaptive'
 887         payload = {
 888             'jsonrpc': '2.0',
 889             'id': 1,
 890             'method': 'Addons.GetAddonDetails',
 891             'params': {
 892                 'addonid': type,
 893                 'properties': ['enabled']
 894             }
 895         }
 896         response = xbmc.executeJSONRPC(json.dumps(payload))
 897         data = json.loads(response)
 898         if not 'error' in data.keys():
 899             if data['result']['addon']['enabled'] == True:
 900                 return type
 901         return None
 902
 903     def set_library (self, library):
 904         """Adds an instance of the Library class
 905
 906         Parameters
 907         ----------
 908         library : :obj:`Library`
 909             instance of the Library class
 910         """
 911         self.library = library
 912
 913     def track_event(self, event):
 914         """
 915         Send a tracking event if tracking is enabled
 916         :param event: the string idetifier of the event
 917         :return: None
 918         """
 919         # Check if tracking is enabled
 920         enable_tracking = (self.addon.getSetting('enable_tracking') == 'true')
 921         if enable_tracking:
 922             #Get or Create Tracking id
 923             tracking_id = self.addon.getSetting('tracking_id')
 924             if tracking_id is '':
 925                 tracking_id = str(uuid4())
 926                 self.addon.setSetting('tracking_id', tracking_id)
 927             # Send the tracking event
 928             tracker = Tracker.create('UA-46081640-5', client_id=tracking_id)
 929             tracker.send('event', event)