4407b87e4e19a51a4f535d51a120f9ab6a906d71
[plugin.video.netflix.git] / 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)