def getRecordByNumber(self, request_number): name = '' imageBMP = None if isinstance(self.__phonebook, dict): for item in self.__phonebook: for number in self.__phonebook[item]['numbers']: if self.__phoneBookFacade.compareNumbers( number, request_number, ccode=self.Mon.cCode): tools.writeLog( 'Match an entry in database for %s: %s' % (request_number, item), xbmc.LOGNOTICE) name = item fname = os.path.join( __ImageCache__, hashlib.md5(item.encode('utf-8')).hexdigest() + '.jpg') if os.path.isfile(fname): tools.writeLog( 'Load image from cache: %s' % (os.path.basename(fname)), xbmc.LOGNOTICE) imageBMP = fname break return {'name': name, 'imageBMP': imageBMP}
def handleIncomingCall(self, line): if line.number_called in self.Mon.exnum_list: self.__hide = True return self.handlePlayerProps('incoming') if len(line.number_caller) > 0: caller_num = line.number_caller tools.writeLog( 'trying to resolve name from incoming number %s' % (caller_num), xbmc.LOGNOTICE) record = self.getRecordByNumber(caller_num) name = record['name'] icon = __IconOk__ if record['imageBMP'] == '' else record[ 'imageBMP'] if not name: name = self.getNameByKlickTel(caller_num) if name: icon = __IconKlickTel__ else: icon = __IconUnknown__ name = __LS__(30012) else: name = __LS__(30012) caller_num = __LS__(30016) icon = __IconUnknown__ tools.writeLog('Incoming call from %s (%s)' % (name, caller_num), xbmc.LOGNOTICE) tools.notify(__LS__(30010), __LS__(30011) % (name, caller_num), icon, self.Mon.dispMsgTime)
def calc_boundaries(direction): sheet_m = int( xbmcgui.Window(10000).getProperty('calendar_month')) + direction sheet_y = int(xbmcgui.Window(10000).getProperty('calendar_year')) if sheet_m < 1: sheet_m = 12 sheet_y -= 1 elif sheet_m > 12: sheet_m = 1 sheet_y += 1 if sheet_y == datetime.today().year: if sheet_m < datetime.today().month or sheet_m > datetime.today( ).month + tools.getAddonSetting('timemax', sType=tools.NUM): tools.writeLog('prev/next month outside boundary') return else: if sheet_m + 12 > datetime.today().month + tools.getAddonSetting( 'timemax', sType=tools.NUM): tools.writeLog('prev/next month outside boundary') return xbmcgui.Window(10000).setProperty('calendar_month', str(sheet_m)) xbmcgui.Window(10000).setProperty('calendar_year', str(sheet_y)) _header = '%s %s' % (__LS__(30119 + sheet_m), sheet_y) xbmcgui.Window(10000).setProperty('calendar_header', _header)
def handleIncomingCall(self, line): if line.number_called in self.Mon.exnum_list: self.__hide = True return self.handlePlayerProps('incoming') if len(line.number_caller) > 0: caller_num = line.number_caller tools.writeLog( 'trying to resolve name from incoming number %s' % (tools.mask(caller_num)), xbmc.LOGNOTICE) record = self.getRecordByNumber(caller_num) name = record['name'] icon = ICON_OK if record['imageBMP'] == '' else record['imageBMP'] if not name: name = LOC(30012) icon = ICON_UNKNOWN else: caller_num = LOC(30016) name = LOC(30012) icon = ICON_UNKNOWN tools.writeLog( 'Incoming call from %s (%s)' % (tools.mask(name), tools.mask(caller_num)), xbmc.LOGNOTICE) tools.notify(LOC(30010), LOC(30011) % (name, caller_num), icon, self.Mon.dispMsgTime, deactivateSS=True)
def prepareForAddon(cls, event, timebase=datetime.now(), optTimeStamps=True): _ts = parser.parse(event['start'].get('dateTime', event['start'].get('date', ''))) _end = parser.parse(event['end'].get('dateTime', event['end'].get('date', ''))) _tdelta = relativedelta.relativedelta(_end.date(), _ts.date()) if event.get('allday', 0) > 0: if _tdelta.months == 0 and _tdelta.weeks == 0 and _tdelta.days == 0: event.update({'range': ''}) elif _tdelta.months == 0 and _tdelta.weeks == 0 and _tdelta.days == 1: event.update({'range': __LS__(30111)}) elif _tdelta.months == 0 and _tdelta.weeks == 0: event.update({'range': __LS__(30112) % (_tdelta.days)}) elif _tdelta.months == 0 and _tdelta.weeks == 1: event.update({'range': __LS__(30113)}) elif _tdelta.months == 0 and _tdelta.weeks > 0: event.update({'range': __LS__(30114) % (_tdelta.weeks)}) elif _tdelta.months == 1: event.update({'range': __LS__(30115)}) elif _tdelta.months > 1: event.update({'range': __LS__(30116) % (_tdelta.months)}) else: event.update({'range': __LS__(30117)}) else: if _ts != _end: event.update({ 'range': _ts.strftime('%H:%M') + ' - ' + _end.strftime('%H:%M') }) else: event.update({'range': _ts.strftime('%H:%M')}) if optTimeStamps: t.writeLog('calculate additional timestamps') _tdelta = relativedelta.relativedelta(_ts.date(), timebase.date()) if _tdelta.months == 0: if _tdelta.days == 0: ats = __LS__(30139) elif _tdelta.days == 1: ats = __LS__(30140) elif _tdelta.days == 2: ats = __LS__(30141) elif 3 <= _tdelta.days <= 6: ats = __LS__(30142) % (_tdelta.days) elif _tdelta.weeks == 1: ats = __LS__(30143) elif _tdelta.weeks > 1: ats = __LS__(30144) % (_tdelta.weeks) else: ats = __LS__(30117) elif _tdelta.months == 1: ats = __LS__(30146) else: ats = __LS__(30147) % (_tdelta.months) event.update({'timestamps': ats}) return event
def getRecordByNumber(self, request_number): name = '' imageBMP = None if isinstance(self.__phonebook, dict): for item in self.__phonebook: for number in self.__phonebook[item]['numbers']: if self.__phoneBookFacade.compareNumbers( number, request_number, ccode=self.Mon.cCode): tools.writeLog( 'Match an entry in database for %s: %s' % (tools.mask(request_number), tools.mask(item)), xbmc.LOGNOTICE) name = item fname = os.path.join( IMAGECACHE, re.sub('\D', '', number.replace('+', '00')) + '.jpg') if os.path.isfile(fname): tools.writeLog('Load image from cache', xbmc.LOGNOTICE) imageBMP = fname break return {'name': name, 'imageBMP': imageBMP}
def setPowerOffEvent(): # Create notification file try: open(POWER_OFF_FILE, 'w').close() return True except IOError: tools.writeLog('Unable to create power off file %s' % POWER_OFF_FILE, level=xbmc.LOGERROR) return False
def getNameByKlickTel(self, request_number): if self.Mon.useKlickTelReverse: if self.__klicktel is None: self.__klicktel = KlickTel.KlickTelReverseSearch() try: return self.__klicktel.search(request_number) except Exception as e: tools.writeLog(str(e), level=xbmc.LOGERROR) return False
def getNameByKlickTel(self, request_number): if self.Mon.useKlickTelReverse: if self.__klicktel is None: self.__klicktel = KlickTel.KlickTelReverseSearch() try: return self.__klicktel.search(request_number) except Exception, e: tools.writeLog('Error at line %s' % (sys.exc_info()[-1].tb_lineno)) tools.writeLog(e.message, level=xbmc.LOGERROR)
def checkOutdatedRecordings(self, mode): nodedata = self.readStatusXML('title') for item in nodedata: if not item in self.__recTitles: self.__recTitles.append(item) tools.writeLog('Recording of "%s" is active' % (item)) for item in self.__recTitles: if not item in nodedata: self.__recTitles.remove(item) tools.writeLog('Recording of "%s" has finished' % (item)) if mode is None: self.deliverMail(__LS__(30047) % (release.hostname, item))
def getPowerOffEvent(remove=True): if os.path.isfile(POWER_OFF_FILE): if remove: try: os.remove(POWER_OFF_FILE) except OSError: tools.writeLog('Unable to remove power off file %s' % POWER_OFF_FILE, level=xbmc.LOGERROR) return False return True return False # No event
def get_calendarIdFromSetup(self, setting): calId = [] _cals = t.getAddonSetting(setting).split(', ') if len(_cals) == 1 and _cals[0] == 'primary': calId.append('primary') else: cals = self.get_calendars() for cal in cals: if cal.get('summaryOverride', cal.get('summary', 'primary')) in _cals: calId.append(cal.get('id')) t.writeLog('getting cal ids from setup: %s' % (', '.join(calId))) return calId
def readStatusXML(self, xmlnode): nodedata = [] try: _xml = minidom.parseString(self.getPvrStatusXML()) nodes = _xml.getElementsByTagName(xmlnode) for node in nodes: if node: nodedata.append(node.childNodes[0].data) return nodedata except TypeError: tools.writeLog("Could not read XML tree from %s" % self.__server, xbmc.LOGERROR) return nodedata
def connect(self, notify=False): if self.__s is not None: self.__s.close() self.__s = None try: self.__s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.__s.settimeout(30) self.__s.connect((self.Mon.server, LISTENPORT)) except socket.error as e: if notify: tools.notify(__LS__(30030), __LS__(30031) % (self.Mon.server, LISTENPORT), __IconError__) tools.writeLog('Could not connect to %s:%s' % (self.Mon.server, LISTENPORT), level=xbmc.LOGERROR) tools.writeLog('%s' % (e), level=xbmc.LOGERROR) return False except Exception as e: tools.writeLog('%s' % (e), level=xbmc.LOGERROR) return False else: tools.writeLog( 'Connected, listen to %s on port %s' % (self.Mon.server, LISTENPORT), xbmc.LOGNOTICE) self.__s.settimeout(0.2) return True
def getPhonebook(self): if self.__phoneBookFacade is None: self.__phoneBookFacade = PhoneBookFacade(imagepath=__ImageCache__) setting_keys = self.__phoneBookFacade.get_setting_keys() for key in setting_keys: setting_keys[key] = __addon__.getSetting(key) self.__phoneBookFacade.set_settings(setting_keys) if self.__phonebook is None: try: self.__phonebook = self.__phoneBookFacade.getPhonebook() tools.writeLog( '%s entries from %s loaded, %s images cached' % (len(self.__phonebook), self.Mon.server, self.__phoneBookFacade.imagecount()), xbmc.LOGNOTICE) except self.__phoneBookFacade.HostUnreachableException: tools.writeLog('Host %s unreachable' % (self.Mon.server), level=xbmc.LOGERROR) tools.notify(__LS__(30030), __LS__(30031) % (self.Mon.server, LISTENPORT), __IconError__) except self.__phoneBookFacade.LoginFailedException: tools.writeLog('Login failed. Check username/password', level=xbmc.LOGERROR) tools.notify(__LS__(30033), __LS__(30034), __IconError__) except self.__phoneBookFacade.InternalServerErrorException: tools.writeLog('Internal server error', level=xbmc.LOGERROR) tools.notify(__LS__(30035), __LS__(30036), __IconError__)
def setWakeup(self): if xbmc.getCondVisibility('Player.Playing'): tools.writeLog('Stopping Player') xbmc.Player().stop() _flags = self.calcNextSched() tools.writeLog( 'Instruct the system to shut down using %s' % ('Application' if self.__shutdown == 0 else 'OS'), xbmc.LOGNOTICE) tools.writeLog('Wake-Up Unix Time: %s' % (self.__wakeUpUT), xbmc.LOGNOTICE) tools.writeLog( 'Flags on resume points will be later {0:05b}'.format(_flags)) os.system( '%s%s %s %s' % (self.__sudo, SHUTDOWN_CMD, self.__wakeUpUT, self.__shutdown)) if self.__shutdown == 0: xbmc.shutdown() xbmc.sleep(1000) # If we suspend instead of poweroff the system, we need the flags to control the main loop of the service. # On suspend we have to resume the service on resume points instead of start on poweron/login. # additional we set the resume flag in calcNextSched if necessary return _flags
def get_calendars(self): if not os.path.exists( self.TEMP_STORAGE_CALENDARS) or not t.lastmodified( self.TEMP_STORAGE_CALENDARS, 60): t.writeLog('establish online connection for getting calendars') self.establish() cal_list = self.service.calendarList().list().execute() cals = cal_list.get('items', []) with open(self.TEMP_STORAGE_CALENDARS, 'w') as filehandle: json.dump(cals, filehandle) return cals else: t.writeLog('getting calendars from local storage') with open(self.TEMP_STORAGE_CALENDARS, 'r') as filehandle: return json.load(filehandle)
def getPvrStatusXML(self): _attempts = self.__maxattempts if not self.hasPVR: tools.writeLog('No HTS PVR client installed or inactive', level=xbmc.LOGERROR) tools.Notify().notify(__LS__(30030), __LS__(30032), icon=xbmcgui.NOTIFICATION_ERROR) return None else: while self.hasPVR and _attempts > 0: # try DigestAuth as first, as this is the default auth on TVH > 3.9 try: conn = requests.get('%s:%s/status.xml' % (self.__server, self.__port), auth=requests.auth.HTTPDigestAuth( self.__user, self.__pass)) conn.close() if conn.status_code == 200: tools.writeLog('Getting status.xml (Digest Auth)') return conn.content else: # try BasicAuth as older method conn = requests.get('%s:%s/status.xml' % (self.__server, self.__port), auth=requests.auth.HTTPBasicAuth( self.__user, self.__pass)) conn.close() if conn.status_code == 200: tools.writeLog('Getting status.xml (Basic Auth)') return conn.content if conn.status_code == 401: tools.writeLog('Unauthorized access (401)') break except requests.ConnectionError: _attempts -= 1 tools.writeLog('%s unreachable, remaining attempts: %s' % (self.__server, _attempts)) xbmc.sleep(5000) continue tools.Notify().notify(__LS__(30030), __LS__(30031), icon=xbmcgui.NOTIFICATION_ERROR) return None
def get_events(self, storage, timeMin, timeMax, maxResult=30, calendars='primary'): if not os.path.exists(storage) or not t.lastmodified(storage, 60): t.writeLog('establish online connection for getting events') self.establish() events = [] for cal in calendars: cal_events = self.service.events().list( calendarId=cal, timeMin=timeMin, timeMax=timeMax, maxResults=maxResult, singleEvents=True, orderBy='startTime').execute() _evs = cal_events.get('items', []) if _evs: # set additional attributes calColor = self.get_calendarBGcolorImage(cal) for _ev in _evs: _ts = parser.parse(_ev['start'].get( 'dateTime', _ev['start'].get('date', ''))).timetuple() _ev.update({'timestamp': int(time.mktime(_ts))}) _ev.update({'icon': calColor}) gadget = _ev.get('gadget', None) if gadget: if gadget.get('preferences').get( 'goo.contactsEventType') == 'BIRTHDAY': _ev.update({'specialicon': __cake__}) events.extend(_evs) events.sort(key=operator.itemgetter('timestamp')) with open(storage, 'w') as filehandle: json.dump(events, filehandle) else: t.writeLog('getting events from local storage') with open(storage, 'r') as filehandle: events = json.load(filehandle) return events
def connect(self, notify=False): if self.__s is not None: self.__s.close() self.__s = None try: self.__s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.__s.settimeout(30) self.__s.connect((self.Mon.server, LISTENPORT)) except socket.error, e: if notify: tools.notify(LOC(30030), LOC(30031) % (self.Mon.server, LISTENPORT), ICON_ERROR) tools.writeLog('Could not connect to %s:%s' % (self.Mon.server, LISTENPORT), level=xbmc.LOGERROR) tools.writeLog(e.message, level=xbmc.LOGERROR) return False
def handleOutgoingCall(self, line): if line.number_used in self.Mon.exnum_list: self.__hide = True return if self.Mon.optShowOutgoing: self.handlePlayerProps('outgoing') record = self.getRecordByNumber(line.number_called) name = __LS__(30012) if record['name'] == '' else record['name'] icon = __IconDefault__ if record['imageBMP'] == '' else record[ 'imageBMP'] tools.notify(__LS__(30013), __LS__(30014) % (name, line.number_called), icon) tools.writeLog( 'Outgoing call from %s to %s' % (line.number_used, line.number_called), xbmc.LOGNOTICE)
def switch(self, cmd, ain=None): # Call an actor method if self.__fbSID is None: t.writeLog('Not logged in', level=xbmc.LOGERROR) return params = { 'switchcmd': cmd, 'sid': self.__fbSID, } if ain: params['ain'] = ain response = self.session.get(self.base_url + '/webservices/homeautoswitch.lua', params=params, verify=False) response.raise_for_status() xbmcgui.Window(10000).setProperty('fritzact.timestamp', str(int(time()))) return response.text.strip()
def handleOutgoingCall(self, line): if line.number_used in self.Mon.exnum_list: self.__hide = True return if self.Mon.optShowOutgoing: self.handlePlayerProps('outgoing') record = self.getRecordByNumber(line.number_called) name = LOC(30012) if record['name'] == '' else record['name'] icon = ICON_OK if record['imageBMP'] == '' else record['imageBMP'] tools.notify(LOC(30013), LOC(30014) % (name, line.number_called), icon, deactivateSS=True) tools.writeLog( 'Outgoing call from %s to %s' % (tools.mask(line.number_used), tools.mask(line.number_called)), xbmc.LOGNOTICE)
def updateAutoModeDialog(self): if not self.__dialog_pb is None: if self.__auto_mode_counter == 0: self.disableScreensaver() tools.writeLog('Display countdown dialog for %s secs' % (self.__auto_mode_set)) if xbmc.getCondVisibility('VideoPlayer.isFullscreen'): tools.writeLog( 'Countdown possibly invisible (fullscreen mode)') tools.writeLog('Showing additional notification') tools.Notify().notify( __LS__(30010), __LS__(30011) % (self.__auto_mode_set)) # actualize progressbar if self.__auto_mode_counter < self.__auto_mode_set: __percent = int(self.__auto_mode_counter * 100 / self.__auto_mode_set) self.__dialog_pb.update( __percent, __LS__(30010), __LS__(30011) % (self.__auto_mode_set - self.__auto_mode_counter)) self.__auto_mode_counter += 1 if self.__auto_mode_counter == self.__auto_mode_set: return True return False
def start(self): if self.connect(notify=True): # MAIN SERVICE while not xbmc.abortRequested: # ToDo: investigate more from https://pymotw.com/2/select/index.html#module-select # i.e check exception handling try: fbdata = self.__s.recv(512) line = self.CallMonitorLine(fbdata) { 'CALL': self.handleOutgoingCall, 'RING': self.handleIncomingCall, 'CONNECT': self.handleConnected, 'DISCONNECT': self.handleDisconnected }.get(line.command)(line) except socket.timeout: pass except socket.error, e: tools.writeLog('No connection to %s, try to respawn' % (self.Mon.server), level=xbmc.LOGERROR) tools.writeLog(e.message, level=xbmc.LOGERROR) self.connect() except IndexError: tools.writeLog('Communication failure', level=xbmc.LOGERROR) self.connect() except Exception, e: tools.writeLog('Error at line %s' % (sys.exc_info()[-1].tb_lineno)) tools.writeLog(e.message, level=xbmc.LOGERROR) break
def countDown(cls, counter=5): __bar = 0 __percent = 0 __counter = counter __idleTime = xbmc.getGlobalIdleTime() # deactivate screensaver (send key select) if xbmc.getCondVisibility('System.ScreenSaverActive'): query = {"method": "Input.Select"} tools.jsonrpc(query) if xbmc.getCondVisibility('VideoPlayer.isFullscreen'): tools.writeLog('Countdown possibly invisible (fullscreen mode)') tools.writeLog('Showing additional notification') tools.Notify().notify(__LS__(30010), __LS__(30011) % (__counter)) # show countdown tools.writeLog('Display countdown dialog for %s secs' % __counter) pb = xbmcgui.DialogProgressBG() pb.create(__LS__(30010), __LS__(30011) % __counter) pb.update(__percent) # actualize progressbar while __bar <= __counter: __percent = int(__bar * 100 / __counter) pb.update(__percent, __LS__(30010), __LS__(30011) % (__counter - __bar)) if __idleTime > xbmc.getGlobalIdleTime(): tools.writeLog('Countdown aborted by user', level=xbmc.LOGNOTICE) pb.close() return True xbmc.sleep(1000) __idleTime += 1 __bar += 1 pb.close() return False
def deliverMail(self, message): if self.__notification: try: __port = {'None': 25, 'SSL/TLS': 465, 'STARTTLS': 587} __s_msg = Message() __s_msg.set_charset(self.__charset) __s_msg.set_payload(message, charset=self.__charset) __s_msg["Subject"] = __LS__(30046) % (release.hostname) __s_msg["From"] = self.__smtpfrom __s_msg["To"] = self.__smtpto if self.__smtpenc == 'STARTTLS': __s_conn = smtplib.SMTP(self.__smtpserver, __port[self.__smtpenc]) __s_conn.ehlo() __s_conn.starttls() elif self.__smtpenc == 'SSL/TLS': __s_conn = smtplib.SMTP_SSL(self.__smtpserver, __port[self.__smtpenc]) __s_conn.ehlo() else: __s_conn = smtplib.SMTP(self.__smtpserver, __port[self.__smtpenc]) __s_conn.login(self.__smtpuser, self.__smtppass) __s_conn.sendmail(self.__smtpfrom, self.__smtpto, __s_msg.as_string()) __s_conn.close() tools.writeLog('Mail delivered to %s.' % (self.__smtpto), level=xbmc.LOGINFO) return True except Exception as e: tools.writeLog( 'Mail could not be delivered. Check your settings.', level=xbmc.LOGERROR) tools.writeLog(e) return False else: tools.writeLog('"%s" completed, no Mail delivered.' % (message)) return True
def __init__(self): self.getSettings() self.base_url = self.__fbtls + self.__fbserver self.session = requests.Session() if self.__fbSID is None or (int(time()) - self.__lastLogin > 600): t.writeLog( 'SID is none/last login more than 10 minutes ago, try to login' ) sid = None try: response = self.session.get(self.base_url + '/login_sid.lua', verify=False) xml = ET.fromstring(response.text) if xml.find('SID').text == "0000000000000000": challenge = xml.find('Challenge').text url = self.base_url + '/login_sid.lua' response = self.session.get(url, params={ "username": self.__fbuser, "response": self.calculate_response( challenge, self.__fbpasswd), }, verify=False) xml = ET.fromstring(response.text) if xml.find('SID').text == "0000000000000000": blocktime = int(xml.find('BlockTime').text) t.writeLog( "Login failed, please wait %s seconds" % (blocktime), xbmc.LOGERROR) t.notifyOSD(__addonname__, __LS__(30012) % (blocktime)) else: sid = xml.find('SID').text except (requests.exceptions.ConnectionError, TypeError): t.writeLog('FritzBox unreachable', level=xbmc.LOGERROR) t.notifyOSD(__addonname__, __LS__(30010)) self.__fbSID = sid self.__lastLogin = int(time()) __addon__.setSetting('SID', self.__fbSID) __addon__.setSetting('lastLogin', str(self.__lastLogin))
def controller(mode=None, handle=None, content=None, eventId=None, actor=None): now = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0).isoformat() + 'Z' timemax = ( datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0) + relativedelta.relativedelta(months=tools.getAddonSetting( 'timemax', sType=tools.NUM))).isoformat() + 'Z' if mode == 'load_glotz_key': glotz_apikey = tools.dialogFile(__LS__(30089)) if glotz_apikey != '': tools.setAddonSetting('glotz_apikey', glotz_apikey) tools.writeLog('API key for glotz.info successfull stored') tools.Notify().notify(__LS__(30010), __LS__(30073)) elif mode == 'abort_reminders': tools.writeLog('abort notification service by setup', xbmc.LOGNOTICE) xbmcgui.Window(10000).setProperty('reminders', '0') elif mode == 'getcontent': googlecal = Calendar() googlecal.build_sheet(handle, TEMP_STORAGE_EVENTS, content, now, timemax, maxResult=30) elif mode == 'getinfo' and eventId != '': googlecal = Calendar() events = eventId.strip(' ').split(' ') _header = '' _msg = '' for event in events: _ev = googlecal.get_event(event, TEMP_STORAGE_EVENTS) _mev = googlecal.prepareForAddon(_ev, optTimeStamps=True) _time = '' if _mev.get( 'range', '') == '' else '[B]%s[/B]: ' % (_mev.get('range')) if actor and actor == 'eventlist': _header = 'S%02iE%02i: %s' % ( _mev.get('season'), _mev.get('episode'), _mev.get('title')) _msg = '%s' % (_mev.get('plot')) else: _header = '%s %s %s' % (__LS__(30109), __LS__(30145), _mev.get('shortdate', '')) _msg += '%s%s[CR]%s[CR][CR]' % (_time, _mev.get( 'summary', ''), _mev.get('description') or __LS__(30093)) tools.dialogOK(_header, _msg) elif mode == 'prev': calc_boundaries(-1) elif mode == 'next': calc_boundaries(1) # this is the real controller bootstrap elif mode == 'gui': try: Popup = xbmcgui.WindowXMLDialog(__xml__, __path__) Popup.doModal() del Popup except RuntimeError as e: raise FileNotFoundException('%s: %s' % (e.message, __xml__)) else: pass
if __name__ == '__main__': action = None content = None eventId = None actor = None _addonHandle = None arguments = sys.argv if len(arguments) > 1: if arguments[0][0:6] == 'plugin': # calling as plugin path _addonHandle = int(arguments[1]) arguments.pop(0) arguments[1] = arguments[1][1:] tools.writeLog('parameter hash: %s' % (str(arguments[1])), xbmc.LOGNOTICE) params = tools.ParamsToDict(arguments[1]) action = params.get('action', '') content = params.get('content', '') eventId = params.get('id', '') actor = params.get('actor') # call the controller of MVC try: if action is not None: controller(mode=action, handle=_addonHandle, content=content, eventId=eventId, actor=actor) else: