def getAvailablePlugins(self):
        pluginDB = self.__getPluginDB()
        # default plugins
        update = False
        fileNames = self.__getFileNamesFromFolder(self.defaultFolder)
        for fileName in fileNames:
            try:
                modTime = os.path.getmtime( os.path.join(self.defaultFolder,fileName+'.py'))
            except OSError:
                modTime = 0
            if fileName not in pluginDB or modTime > pluginDB[fileName]['modified']:
                logger.info('load plugin: '+ str(fileName))
                # try to import plugin
                aPlugin = self.__getPluginData(fileName)
                aPlugin['modified'] = modTime
                if aPlugin:
                    pluginDB[fileName] = aPlugin
                    update = True
        # check pluginDB for obsolete entries
        deletions = []
        for pluginID in pluginDB:
            if pluginID not in fileNames:
                deletions.append(pluginID)
        for id in deletions:
            del pluginDB[id]
        if update or deletions:
            self.__updateSettings(pluginDB)
            self.__updatePluginDB(pluginDB)

        return self.getAvailablePluginsFromDB()

def resolveLinkcrypt(sUrl, hosters):
    oRequest = cRequestHandler(sUrl)
    sHtmlContent = oRequest.request()
    pattern = '<form action="http://linkcrypt.ws/out.html"[^>]*?>.*?'
    pattern += '<input[^>]*?value="(.+?)"[^>]*?name="file"'
    aResult = cParser().parse(sHtmlContent, pattern)
    if not aResult[0]:
        return

    for idx, weblink_id in enumerate(aResult[1]):
        try:
            oRequest = cRequestHandler("http://linkcrypt.ws/out.html")
            oRequest.addParameters('file', weblink_id)
            data = oRequest.request()
            link = re.compile("top.location.href=doNotTrack\('(.+?)'\)").findall(data)[0]
            hname = getHosterName(link)
            hname = "Part %d - %s" % (idx + 1, hname)
            logger.info("Resolved LinkCrypt link: %s" % link)
            hoster = dict()
            hoster['link'] = link
            hoster['name'] = hname
            hoster['displayedName'] = hname
            hosters.append(hoster)
        except Exception, detail:
            logger.info(detail)
            pass

def load():
    logger.info("Load %s" % SITE_NAME)
    oGui = cGui()
    oGui.addFolder(cGuiElement('Filme', SITE_IDENTIFIER, 'showMovieMenu'))
    oGui.addFolder(cGuiElement('Serien', SITE_IDENTIFIER, 'showTvShowMenu'))
    oGui.addFolder(cGuiElement('Suche', SITE_IDENTIFIER, 'showSearch'))
    oGui.setEndOfDirectory()

def getHosters():
    oParams = ParameterHandler()
    sChannelUrl = oParams.getValue('channelUrl')
    sChannelName = oParams.getValue('channelName')
    logger.info('get stream url for URL: ' + sChannelUrl)

    oRequestHandler = cRequestHandler(sChannelUrl)
    oRequestHandler.addHeaderEntry('Referer', URL_MAIN)
    sHtmlContent = oRequestHandler.request();

    hosters = []

    sPattern = "'file': '(.*?)',"
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)
    if aResult[0]:
        sUrl = str(aResult[1])[2:-2]
        logger.info('load channel ' + sChannelName + ' with url ' + sUrl)

        hoster = {}
        hoster['link'] = sUrl
        hoster['name'] = 'streamcloud'  # dummy
        hosters.append(hoster)
    hosters.append('getHosterUrl')
    return hosters

def searchAlter(params):
    searchText = params.getValue('searchTitle')
    searchImdbId = params.getValue('searchImdbID')
    import threading
    oGui = cGui()
    aPlugins = []
    aPlugins = cPluginHandler().getAvailablePlugins()
    dialog = xbmcgui.DialogProgress()
    dialog.create('xStream',"Searching...")
    numPlugins = len(aPlugins)
    count = 0
    threads = []
    for pluginEntry in aPlugins:
        dialog.update(count*100/numPlugins,'Searching: '+str(pluginEntry['name'])+'...')
        count += 1
        logger.info('Searching for "'+searchText+'" at '+pluginEntry['id'])
        t = threading.Thread(target=pluginSearch, args=(pluginEntry,searchText))
        threads += [t]
        t.start()
    for t in threads: 
        t.join()
    dialog.close()
    oGui.setView()
    oGui.setEndOfDirectory()
    #xbmc.executebuiltin('Container.Update')
    return True

def _getHostFromUrl(sUrl, sServername):
    # Seite abrufen
    sHtmlContent = cRequestHandler(sUrl).request()

    # JSon mit den Links ermitteln
    pattern = '(\[{".*?}\])'
    aResult = cParser().parse(sHtmlContent, pattern)

    # Nichts gefunden? => Raus hier
    if not aResult[0] or not aResult[1][0]: 
        logger.info("hoster pattern did not match")
        return False

    # hosterliste initialisieren
    hosters = []

    # Alle Einträge durchlaufen und Hostereintrag erstellen
    for entry in json.loads(aResult[1][0]):
        if 'file' not in entry or 'label' not in entry: continue
        sLabel = sServername + ' - ' + entry['label'].encode('utf-8')
        hoster = dict()
        hoster['link'] = entry['file']
        if entry['label'].encode('utf-8')[:-1] in QUALITY_ENUM:
            hoster['quality'] = QUALITY_ENUM[entry['label'].encode('utf-8')[:-1]]
        hoster['name'] = sLabel
        hoster['resolveable'] = True
        hosters.append(hoster)

    # Hoster zurückgeben
    return hosters

    def __addPluginsToSettings(self, data):
        """
        data (dict): containing plugininformations
        """
        import xml.etree.ElementTree as ET

        tree = ET.parse(self.settingsFile)
        # find Element for plugin Settings
        pluginElem = False
        for elem in tree.findall("category"):
            if elem.attrib["label"] == "30022":
                pluginElem = elem
                break
        if not pluginElem:
            logger.info("pluginElement not found")
            return False
        # add plugins to settings
        for pluginID in data:
            plugin = data[pluginID]
            attrib = {"default": "false", "type": "bool"}
            attrib["id"] = "plugin_%s" % pluginID
            attrib["label"] = plugin["name"]
            newPlugin = ET.Element()
            ET.SubElement(pluginElem, "setting", attrib)
        tree.write(self.settingsFile)

def showSeasons():
    logger.info('load showSeasons')
    oParams = ParameterHandler()
    sTitle = oParams.getValue('Title')
    sPattern = '<a href="#season-(.*?)" data-parent=".*?>(.*?)</a>'

    # request
    sHtmlContent = __getHtmlContent()
    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)

    oGui = cGui()
    if aResult[0]:
        for sId, seasonNum in aResult[1]:
            guiElement = cGuiElement('%s - Staffel %s' % (sTitle, seasonNum), SITE_IDENTIFIER, 'showEpisodes')
            guiElement.setMediaType('season')
            guiElement.setSeason(seasonNum)
            guiElement.setTVShowTitle(sTitle)

            oParams.setParam('Season', seasonNum)
            oGui.addFolder(guiElement, oParams)

    oGui.setView('seasons')
    oGui.setEndOfDirectory()

def showSeries(sUrl=False):
    logger.info('load showSeries')
    oParams = ParameterHandler()

    if not sUrl:
        sUrl = oParams.getValue('sUrl')

    sPagePattern = '<a href="' + sUrl + '(\d+).html">'

    # request
    sHtmlContent = __getHtmlContent(sUrl)
    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPagePattern)

    pages = 1
    if aResult[0]:
        if representsInt(aResult[1][-1]):
            pages = aResult[1][-1]

    oGui = cGui()

    # because sometimes 2 pages have the same content
    dupeCheck = []
    for x in range(1, int(pages) + 1):
        dupeCheck = showSeriesPage(oGui, sUrl, x, dupeCheck)

    oGui.setView('tvshows')
    oGui.setEndOfDirectory()

def showEpisodes():
    logger.info('load showEpisodes')
    oParams = ParameterHandler()
    sTitle = oParams.getValue('Title')
    sSeason = oParams.getValue('Season')

    sPattern = 'class="list-group-item".*?<span itemprop="name">Staffel ' + sSeason + ' Episode(?:[\s]*)(.*?)</span>.*?<a class="episode-name" href="(.*?)" title="(.*?)"'

    # request
    sHtmlContent = __getHtmlContent()
    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)

    oGui = cGui()
    if (aResult[0] == True):
        for eNr, link, title in aResult[1]:
            guiElement = cGuiElement('Episode %s - %s' % (eNr, title), SITE_IDENTIFIER, 'showHosters')
            guiElement.setMediaType('episode')
            guiElement.setSeason(sSeason)

            # Special fix for non-int episode numbers (like Attack on Titan 13.5)
            # Can't even check this on thetvdb.com, because AOT 13.5 for example is Season 0 Episode 1
            # May I can use "<airsbefore_episode>" and "<airsbefore_season>" for metadata
            if representsInt(eNr):
                guiElement.setEpisode(eNr)

            guiElement.setTVShowTitle(sTitle)

            oParams.setParam('sUrl', link)
            oGui.addFolder(guiElement, oParams, bIsFolder=False)

    oGui.setView('episodes')
    oGui.setEndOfDirectory()

def searchGlobal():
    import threading
    oGui = cGui()
    oGui.globalSearch = True
    oGui._collectMode = True
    sSearchText = oGui.showKeyBoard()
    if not sSearchText: return True
    aPlugins = []
    aPlugins = cPluginHandler().getAvailablePlugins()
    dialog = xbmcgui.DialogProgress()
    dialog.create('xStream',"Searching...")
    numPlugins = len(aPlugins)
    threads = []
    for count, pluginEntry in enumerate(aPlugins):
        dialog.update((count+1)*50/numPlugins,'Searching: '+str(pluginEntry['name'])+'...')
        logger.info('Searching for %s at %s' % (sSearchText, pluginEntry['id']))
        t = threading.Thread(target=_pluginSearch, args=(pluginEntry,sSearchText,oGui), name =pluginEntry['name'])
        threads += [t]
        t.start()
    for count, t in enumerate(threads):
        t.join()
        dialog.update((count+1)*50/numPlugins+50, t.getName()+' returned')
    dialog.close()
    # deactivate collectMode attribute because now we want the elements really added
    oGui._collectMode = False
    total=len(oGui.searchResults)
    for result in sorted(oGui.searchResults, key=lambda k: k['guiElement'].getSiteName()):
        oGui.addFolder(result['guiElement'],result['params'],bIsFolder=result['isFolder'],iTotal=total)
    oGui.setView()
    oGui.setEndOfDirectory()
    return True

def searchGlobal():
    import threading
    oGui = cGui()
    sSearchText = oGui.showKeyBoard()
    if (sSearchText != False and sSearchText != ''):
        aPlugins = []
        aPlugins = cPluginHandler().getAvailablePlugins()
        dialog = xbmcgui.DialogProgress()
        dialog.create('xStream',"Searching...")
        numPlugins = len(aPlugins)
        count = 0
        threads = []
        for pluginEntry in aPlugins:
            dialog.update(count*100/numPlugins,'Searching: '+str(pluginEntry['name'])+'...')
            count += 1
            logger.info('Searching for %s at %s' % (sSearchText, pluginEntry['id']))
            t = threading.Thread(target=_pluginSearch, args=(pluginEntry,sSearchText,oGui))
            threads += [t]
            t.start()
        for t in threads: 
            t.join()
        dialog.close()
        oGui.setView()
        oGui.setEndOfDirectory()
    return True

def parseMovieEntrySite():
    oParams = ParameterHandler()
    sSecurityValue = oParams.getValue('securityCookie')
    if oParams.exist('sUrl'):
        sUrl = oParams.getValue('sUrl')
        # get movieEntrySite content
        sHtmlContent = __getHtmlContent(sUrl, sSecurityValue)
        sMovieTitle = __createMovieTitle(sHtmlContent)
        # get thumbnail
        result = cParser().parse(sHtmlContent, '<div class="Grahpics">.*?<img src="([^"]+)"')
        thumbnail = URL_MAIN + str(result[1][0]) if result[0] else False

        bIsSerie = __isSerie(sHtmlContent)
        if bIsSerie:
            oGui = cGui()
            aSeriesItems = parseSerieSite(sHtmlContent)
            if not aSeriesItems[0]: return
            total = len(aSeriesItems)
            for aEntry in aSeriesItems[1]:
                seasonNum = str(aEntry)
                guiElement = cGuiElement('%s - Staffel %s' % (sMovieTitle, seasonNum), SITE_IDENTIFIER, 'showEpisodes')
                guiElement.setMediaType('season')
                guiElement.setSeason(seasonNum)
                guiElement.setTVShowTitle(sMovieTitle)

                oParams.setParam('Season', seasonNum)
                if thumbnail:
                    guiElement.setThumbnail(thumbnail)
                oGui.addFolder(guiElement, oParams, iTotal=total)
            oGui.setView('seasons')
            oGui.setEndOfDirectory()
        else:
            logger.info('Movie')
            result = showHosters(sHtmlContent, sMovieTitle)
            return result

def load():
    logger.info("Load %s" % SITE_NAME)

    sSecurityValue = __getSecurityCookieValue()
    oParams = ParameterHandler()
    if sSecurityValue:
        oParams.setParam('securityCookie', sSecurityValue)
    # Create all main menu entries
    oGui = cGui()

    oParams.setParam('sUrl', URL_NEWS)
    oParams.setParam('page', 1)
    oParams.setParam('mediaType', 'news')
    oGui.addFolder(cGuiElement('Neues von Heute', SITE_IDENTIFIER, 'showNews'), oParams)
    oParams.setParam('sUrl', URL_MOVIE_PAGE)
    oParams.setParam('mediaType', 'movie')
    oGui.addFolder(cGuiElement('Filme', SITE_IDENTIFIER, 'showMovieMenu'), oParams)
    oParams.setParam('sUrl', URL_SERIE_PAGE)
    oParams.setParam('mediaType', 'series')
    oGui.addFolder(cGuiElement('Serien', SITE_IDENTIFIER, 'showSeriesMenu'), oParams)
    oParams.setParam('sUrl', URL_DOCU_PAGE)
    oParams.setParam('mediaType', 'documentation')
    oGui.addFolder(cGuiElement('Dokumentationen', SITE_IDENTIFIER, 'showDocuMenu'), oParams)
    oParams.setParam('sUrl', URL_SEARCH)
    oParams.setParam('mediaType', '')
    oGui.addFolder(cGuiElement('Suche', SITE_IDENTIFIER, 'showSearch'), oParams)
    oGui.setEndOfDirectory()

def _search(oGui, sSearchText):
    # Create the request with the search value
    sFullSearchUrl = URL_SEARCH + ("?q=%s" % sSearchText)
    logger.info("Search URL: %s" % sFullSearchUrl)
    sHtmlContent = __getHtmlContent(sFullSearchUrl)
    # Display all items returned...
    __displayItems(oGui, sHtmlContent)

def showCharacters():
    logger.info('load showCharacters')
    oGui = cGui()

    oParams = ParameterHandler()
    sSecurityValue = oParams.getValue('securityCookie')
    if oParams.exist('sUrl') and oParams.exist('page') and oParams.exist('mediaType'):
        siteUrl = oParams.getValue('sUrl')
        # iPage = oParams.getValue('page')
        # sMediaType = oParams.getValue('mediaType')
        # request
        sHtmlContent = __getHtmlContent(siteUrl, sSecurityValue)
        # parse content
        sPattern = 'class="LetterMode.*?>([^>]+)</a>'
        oParser = cParser()
        aResult = oParser.parse(sHtmlContent, sPattern)

    if aResult[0]:
        for aEntry in aResult[1]:
            oGuiElement = cGuiElement(aEntry, SITE_IDENTIFIER, 'ajaxCall')
            # oOutputParameterHandler = ParameterHandler()
            oParams.setParam('character', aEntry[0])
            # oOutputParameterHandler.addParameter('page', iPage)
            # oOutputParameterHandler.addParameter('mediaType', sMediaType)
            # oOutputParameterHandler.addParameter('securityCookie', sSecurityValue)
            if oParams.exist('mediaTypePageId'):
                sMediaTypePageId = oParams.getValue('mediaTypePageId')
                oParams.setParam('mediaTypePageId', sMediaTypePageId)
            oGui.addFolder(oGuiElement, oParams)

    oGui.setEndOfDirectory()

def showSeasons():
    oGui = cGui()
    params = ParameterHandler()
    sTitle = params.getValue('Title')
    seriesId = params.getValue('seriesID')
    sImdb = params.getValue('imdbID')

    logger.info("%s: show seasons of '%s' " % (SITE_NAME, sTitle))

    data = _getJsonContent("series/%s/1" % seriesId)
    rangeStart = not int(data["series"]["movies"])
    total = int(data["series"]["seasons"])
    for i in range(rangeStart, total + 1):
        seasonNum = str(i)
        if i is 0:
            seasonTitle = 'Film(e)'
            dialogType = 'showCinemaMovies'
        else:
            seasonTitle = '%s - Staffel %s' %(sTitle, seasonNum)
            if params.getValue('specific') == 'Episode':
                dialogType = 'randomEpisode'
            else:
                dialogType = 'showEpisodes'
        guiElement = cGuiElement(seasonTitle, SITE_IDENTIFIER, dialogType)
        guiElement.setMediaType('season')
        guiElement.setSeason(seasonNum)
        guiElement.setTVShowTitle(sTitle)

        params.setParam('Season', seasonNum)
        guiElement.setThumbnail(URL_COVER % data["series"]["id"])
        oGui.addFolder(guiElement, params, iTotal = total)
    oGui.setView('seasons')
    oGui.setEndOfDirectory()

def showEpisodes():
    oGui = cGui()
    oParams = ParameterHandler()
    sShowTitle = oParams.getValue('Title')
    seriesId = oParams.getValue('seriesID')
    sImdb = oParams.getValue('imdbID')
    sSeason = oParams.getValue('Season')

    logger.info("%s: show episodes of '%s' season '%s' " % (SITE_NAME, sShowTitle, sSeason))

    data = _getJsonContent("series/%s/%s" % (seriesId, sSeason))
    total = len(data['epi'])
    for episode in data['epi']:
        title = "%d - " % int(episode['epi'])
        if episode['german']:
            title += episode['german'].encode('utf-8')
        else:
            title += episode['english'].encode('utf-8')
        guiElement = cGuiElement(title, SITE_IDENTIFIER, 'showHosters')
        guiElement.setMediaType('episode')
        guiElement.setSeason(data['season'])
        guiElement.setEpisode(episode['epi'])
        guiElement.setTVShowTitle(sShowTitle)
        guiElement.setThumbnail(URL_COVER % data["series"]["id"])
        oParams.setParam('EpisodeNr', episode['epi'])
        oGui.addFolder(guiElement, oParams, bIsFolder = False, iTotal = total)
    oGui.setView('episodes')
    oGui.setEndOfDirectory()

def searchGlobal():
    oGui = cGui()
    sSearchText = oGui.showKeyBoard()
    if (sSearchText != False and sSearchText != ''):
        aPlugins = []
        aPlugins = cPluginHandler().getAvailablePlugins()
        oGui.dialog = xbmcgui.DialogProgress()
        oGui.dialog.create('xStream',"Searching...")
        numPlugins = len(aPlugins)
        count = 0
        for pluginEntry in aPlugins:
            pluginName = str(pluginEntry['name'])
            pluginSiteName = pluginEntry['id']
            oGui.dialog.update(count*100/numPlugins,'Searching: '+pluginName+'...')
            count += 1
            logger.info('Searching for "'+sSearchText+'" at '+pluginName)
            try:
                plugin = __import__(pluginSiteName, globals(), locals())
                function = getattr(plugin, '_search')
                oGuiElement = cGuiElement('[B][COLOR yellow]----'+pluginName+'----[/COLOR][/B]',pluginSiteName,'spacer')
                if len(pluginEntry)>2:
                    oGuiElement.setThumbnail(pluginEntry['icon'])
                oGui.addFolder(oGuiElement)
                function(oGui, sSearchText)
            except:
                logger.info(pluginName+': search failed')
                import traceback
                print traceback.format_exc()
        oGui.dialog.close()
        oGui.setView()
        oGui.setEndOfDirectory()
    return True

def __getHtmlContent(sUrl = None, sSecurityValue=None):
    params = ParameterHandler()

    # Test if a url is available and set it
    if sUrl is None and not params.exist('siteUrl'):
        logger.info("There is no url we can request.")
        return False
    else:
        if sUrl is None:
            sUrl = params.getValue('siteUrl')

    # Test if a security value is available
    if sSecurityValue is None:
        if params.exist('securityCookie'):
            sSecurityValue = params.getValue('securityCookie')
        else :
            sSecurityValue = ''

    # Make the request
    oRequest = cRequestHandler(sUrl)
    #oRequest.addHeaderEntry('Cookie', sSecurityValue)
    #oRequest.addHeaderEntry('Accept', '*/*')
    #oRequest.addHeaderEntry('Host', 'gstream.to')

    return oRequest.request()