def getAddonVideo(self,url):
     html = self.getRequest('http://www.snagfilms.com/embed/player?filmId=%s' % uqp(url))
     url = re.compile('file: "(.+?)"', re.DOTALL).findall(html)
     u = ''
     for x in url: 
         if '6912k' in x: u = x
     if u == '' :
         u = url[-1]
     bspeed = self.addon.getSetting('bitrate')
     if bspeed == '0':
         u = url[0]
     elif bspeed == '2':
         u = url[-1]
     liz = xbmcgui.ListItem(path=u)
     infoList ={}
     infoList['mediatype'] = xbmc.getInfoLabel('ListItem.DBTYPE')
     infoList['Title'] = xbmc.getInfoLabel('ListItem.Title')
     infoList['TVShowTitle'] = xbmc.getInfoLabel('ListItem.TVShowTitle')
     infoList['Year'] = xbmc.getInfoLabel('ListItem.Year')
     infoList['Premiered'] = xbmc.getInfoLabel('Premiered')
     infoList['Plot'] = xbmc.getInfoLabel('ListItem.Plot')
     infoList['Studio'] = xbmc.getInfoLabel('ListItem.Studio')
     infoList['Genre'] = xbmc.getInfoLabel('ListItem.Genre')
     infoList['Duration'] = xbmc.getInfoLabel('ListItem.Duration')
     infoList['MPAA'] = xbmc.getInfoLabel('ListItem.Mpaa')
     infoList['Aired'] = xbmc.getInfoLabel('ListItem.Aired')
     infoList['Season'] = xbmc.getInfoLabel('ListItem.Season')
     infoList['Episode'] = xbmc.getInfoLabel('ListItem.Episode')
     liz.setInfo('video', infoList)
     xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, liz)

 def run(self, oGuiElement, sTitle, sUrl):
     sPluginHandle = cPluginHandler().getPluginHandle();
     #meta = oGuiElement.getInfoLabel()
     meta = {'label': sTitle, 'title': sTitle}
     item = xbmcgui.ListItem(path=sUrl, iconImage="DefaultVideo.png",  thumbnailImage=self.sThumbnail)
     
     item.setInfo( type="Video", infoLabels= meta )
                 
     if (cConfig().getSetting("playerPlay") == '0'):   
                         
         sPlayerType = self.__getPlayerType()
         xbmcPlayer = xbmc.Player(sPlayerType)
         xbmcPlayer.play( sUrl, item )
         xbmcplugin.endOfDirectory(sPluginHandle, True, False, False) 
         
     else:
         xbmcplugin.setResolvedUrl(sPluginHandle, True, item)
     
     timer = int(cConfig().getSetting('param_timeout'))
     xbmc.sleep(timer)
     
     while not xbmc.abortRequested:
         try: 
            self.currentTime = self.getTime()
            self.totalTime = self.getTotalTime()
         except: break
         xbmc.sleep(1000)

def Play(
    resolved_url,
    addon_id,
    video_type,
    title,
    season,
    episode,
    year,
    watch_percent=0.9,
    watchedCallback=None,
    watchedCallbackwithParams=None,
    imdb_id=None,
):
    player = Player()
    common.addon.log("-" + HELPER + "- -" + resolved_url)
    player.set(
        addon_id,
        video_type,
        title,
        season,
        episode,
        year,
        watch_percent,
        watchedCallback,
        watchedCallbackwithParams,
        imdb_id,
    )
    xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=resolved_url))
    return player

def GET_VIDEO_FILE(name, url):
	url="http://www.panet.co.il/Ext/vplayer_lib.php?media="+str(url)+'&start=false'
	req = urllib2.Request(url)
	req.add_header('User-Agent', 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3')
	req.add_header('Host',' fms-eu0.panet.co.il')
	req.add_header('Accept',' text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8')
	req.add_header('Accept-Language',' en-US,en;q=0.5')
	req.add_header('Accept-Encoding', 'deflate')
	req.add_header('Referer',' http://www.panet.co.il/Ext/players/flv5/player.swf')
	req.add_header('Cookie',' __auc=82d7ffe213cb1b4ce1d273c7ba1; __utma=31848767.848342890.1360191082.1360611183.1360620657.4; __utmz=31848767.1360191082.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); __utmb=31848767.4.10.1360620660; __utmc=31848767; __asc=169c084d13ccb4fa36df421055e')
	req.add_header('Connection',' keep-alive')
	response = urllib2.urlopen(req)
	link=response.read()
	response.close()
	match_url_thumb=(re.compile('<link rel="video_src" href="(.+?)"/>').findall(link))
	match_url_thumb=str(match_url_thumb).replace("['", "")
	match_url_thumb=str(match_url_thumb).replace("']", "").strip()
	match_url_thumb=match_url_thumb.replace('%3A',':')
	match_url_thumb=match_url_thumb.replace('%2F','/')
	match_url_thumb=match_url_thumb.replace('http://','')
	match_url_thumb=match_url_thumb.replace('file=','file=http://')
	match_url_thumb=match_url_thumb.replace("www.panet.co.il/Ext/players/flv/playern.swf?type=http&streamer=start&file=","")
	match_url_thumb=match_url_thumb+'|Referer=http://www.panet.co.il/Ext/players/flv5/player.swf'
	listItem = xbmcgui.ListItem(path=str(match_url_thumb))
	xbmcplugin.setResolvedUrl(_thisPlugin, True, listItem)

    def __init__(self):
        self._parse_argv()

        self.tokens = {}
        sortLetterList = list()
        # 0 if false, 1 if true
        hasParentItem = xbmc.getCondVisibility('System.GetBool(filelists.showparentdiritems)')
        ignoreArticles = xbmc.getCondVisibility('System.GetBool(filelists.ignorethewhensorting)')
        wid = xbmcgui.getCurrentWindowId()
        currentWindow = xbmcgui.Window(wid)

        # get sort tokens from advancedsettings.xml
        f = xbmcvfs.File(xbmc.translatePath('special://userdata/advancedsettings.xml'))
        advancedsettings = f.read()
        f.close()

        if advancedsettings:
            root = ET.fromstring(advancedsettings)
            sorttokens = root.find('sorttokens')
            # user specified tokens, proceed to create dictionary
            if sorttokens is not None:
                self.tokens = { token.text.encode('utf-8') : u'' for token in sorttokens.findall('token') }

        if self.TYPE == "scroll":
            xbmcplugin.setResolvedUrl(handle=self.handle, succeeded=False, listitem=xbmcgui.ListItem())
            containerId = self._get_view_mode()
            targetList = currentWindow.getControl(containerId)
            targetList.selectItem(int(self.pos))
            currentWindow.setFocus(targetList)
        elif self.path:
            xbmcplugin.setContent(self.handle, 'files')
            self._parse_files(sortLetterList, hasParentItem, ignoreArticles)
            xbmcplugin.addDirectoryItems(self.handle, sortLetterList)
            xbmcplugin.endOfDirectory(handle=self.handle)
        return

def playVideo(url):
    global quality
    try:
        if ',sesamstrasse' in url:
            regex_suffix_id = ',sesamstrasse(.+?).html'
            try: suffix_id = re.findall(regex_suffix_id, url)[0]
            except: suffix_id = '3000'
        else: suffix_id = '3000'
        content = opener.open(url).read()
        json_uuid = re.findall('player_image-(.+?)_', content)[0]
        json_url = 'http://www.sesamstrasse.de/sendungsinfos/sesamstrasse%s-ppjson_image-%s.json' % (suffix_id, json_uuid)
        json = opener.open(json_url).read()
        regex_qualities = '\.,(.+?),\.'
        qualities = re.findall(regex_qualities, json)[-1].split(',')
        if not (quality in qualities): quality = qualities[-1]
        regex_url = '"src": "http://(.+?)"'
        urls = re.findall(regex_url, json)
        stream_url = ''
        for url in urls:
            if url.endswith('.mp4'):
                stream_url = 'http://' + url[:-6] + quality + '.mp4'
                break
        if not stream_url: return
    except: return
    listitem = xbmcgui.ListItem(path=stream_url)
    xbmcplugin.setResolvedUrl(pluginhandle, True, listitem)

def play(params):
    referer = urllib.unquote_plus(params['referer'])
    file = urllib.unquote_plus(params['file'])
    headers['Referer'] = referer

    i = xbmcgui.ListItem(path=getFile(file))
    xbmcplugin.setResolvedUrl(h, True, i)

def set_resolved_url(stream_url, subtitle_url):
	h1 = '|User-Agent=' + urllib.quote_plus('HDViet/2.0.1 CFNetwork/711.2.23 Darwin/14.0.0')
	h2 = '&Accept=' + urllib.quote_plus('*/*')
	xbmcplugin.setResolvedUrl(addon_handle, succeeded=True, listitem=xbmcgui.ListItem(label = '', path = stream_url))
	
	datapath=xbmc.translatePath(xbmcaddon.Addon().getAddonInfo('profile')).decode("utf-8")
	subtitlePath = os.path.join(datapath,'subs')
	try:
		if subtitle_url != '':
			sublink = subtitle_url.split('/')
			subfile = os.path.join(subtitlePath, sublink[len(sublink)-1])
			if not os.path.exists(subtitlePath):os.mkdir(subtitlePath)
			for file in os.listdir(subtitlePath):
				if os.path.isfile(os.path.join(subtitlePath,file)):
					try:os.remove(os.path.join(subtitlePath,file))
					except:pass
			f = urllib2.urlopen(subtitle_url)
			with open(subfile, "wb") as code:
				code.write(f.read())
			xbmc.sleep(1000)
			timeout = 0
			while not xbmc.Player().isPlaying() and timeout < 60:
				xbmc.sleep(500)
				timeout += 1
			if timeout < 60:
				xbmc.Player().setSubtitles(subfile)
				xbmc.executebuiltin((u'XBMC.Notification(%s,%s,%s)'%('HDViet','[COLOR green]Subtitle Loaded ![/COLOR]',2000)).encode("utf-8"))
			else:xbmc.executebuiltin((u'XBMC.Notification(%s,%s,%s)'%('HDViet','[COLOR red]Connection timed out ![/COLOR]',2000)).encode("utf-8"))
	except:
		pass

def PlayVideo(id):
    import xbmcgui
    import sys

    video, links = GetVideoInformation(id)

    if 'best' not in video:
        return False

    url   = video['best']          
    title = video['title']
    image = video['thumbnail']

    liz = xbmcgui.ListItem(title, iconImage=image, thumbnailImage=image)

    liz.setInfo( type="Video", infoLabels={ "Title": title} )
    liz.setProperty("IsPlayable","true")

    if int(sys.argv[1]) == -1:
        import xbmc
        pl = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
        pl.clear()
        pl.add(url, liz)
        xbmc.Player().play(pl)
    else:
        import xbmcplugin
        liz.setPath(url)
        xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, liz)

    return True

def play_video(url):

	if 'parser.php?surl=' in url: # case for cCloudTv redirecting parser
		try:
			#print 'URL: ' + str(url)
			if '|' in url:
				urls = url.split('|')
				rurl = str(urls[0])
				purl = urls[1]
			else:
				rurl = url
			req = urllib2.Request(rurl)
			res = urllib2.urlopen(req)
			furl = res.geturl()
			if '|' in url:
				url = furl + '|' + purl
			else:
				url = furl
			#print 'RedirectorURL: ' + str(url)
		except:
			pass
			
	media_url = url
	item = xbmcgui.ListItem(name, path = media_url)
	xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item)
	return

def playvideo(param): # Gets the stream from the selected video and plays it
    try:
        stream = gethighspotsstreamurl(param)
        listitem = xbmcgui.ListItem(path=stream)
        xbmcplugin.setResolvedUrl(pluginhandle, True, listitem)
    except:
        xbmcgui.Dialog().ok('Highspots.TV', 'Highspots.TV subscribers you will need to purchase access to view this event.')

def resolveUrl(url):
  if 'fptplay' in url:
    req=urllib2.Request(url)
    req.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:19.0) Gecko/20100101 Firefox/19.0')
    req.add_header('Referer', fptplay)	
    response=urllib2.urlopen(req)
    link=response.read()
    response.close()
    mediaUrl='plugin://plugin.video.f4mTester/?url='+re.compile('"adapt_hds": "(.+?)"').findall(link)[0]
  elif 'htvonline' in url:
    content=makeRequest(url)
    mediaUrl=re.compile("file: \"([^\"]*)\"").findall(content)[0]
  elif 'hplus' in url:
    content=makeRequest(url)  
    mediaUrl=re.compile("var iosUrl = \"(.+?)\"").findall(content)[0]	
  elif 'tv24' in url:
    content=makeRequest(url)  
    videoUrl=re.compile('\'file\': \'http([^\']*)\/playlist.m3u8').findall(content)[0]
    mediaUrl='rtmpe' + videoUrl + ' swfUrl=http://tv24.vn/getflash.ashx pageUrl=http://tv24.vn/ ' + token   
  elif 'zui' in url:
    content=makeRequest(url)  
    mediaUrl=re.compile('livetv_play\(\'player\', \'1\', \'(.+?)\'\)').findall(content)[0]	
  elif 'wezatv' in url or 'giniko' in url:
    content=makeRequest(url)  
    mediaUrl=re.compile('file: "(.+?)"').findall(content)[0]  
  else:
    mediaUrl=url  
  item=xbmcgui.ListItem(path=mediaUrl)
  xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item)	  
  return

def playItem(vodItemURL, vodItemId):
    # obtain a ticket for the video item
    ticketLoader = MakoTicketLoader.MakoTicketLoader(__properties, vodItemURL, vodItemId)
    ticketLoader.loadURL()
    urlEncodedTicket = ticketLoader.getTicket()
    if urlEncodedTicket == '':
        xbmc.log('***** Mako: unable to find ticket for vod item %s' % vodItemURL, xbmc.LOGERROR)
    else:
        # create final URL
	_url = vodItemURL
	if _url.find('?') == -1:
	    _url = _url + '?' + urlEncodedTicket
	else:
	    _url = _url + '&' + urlEncodedTicket
	xbmc.log('***** Mako: final video URL with ticket: %s' % _url, xbmc.LOGDEBUG)
	title = ''
	summary = ''
	thumbnail = ''

        # falsify a user agent
        _user_agent = '|User-Agent=' + urllib.quote_plus('stagefright/1.2 (Linux; Android 4.2.2)')
        _acceptHeader = '&Accept-Language=en-US'

        listItem = xbmcgui.ListItem(title, iconImage = thumbnail, thumbnailImage = thumbnail, path=_url + _user_agent + _acceptHeader)
        listItem.setInfo(type='Video', infoLabels={ "Title": urllib.unquote(title), "Plot": urllib.unquote(summary)})
        listItem.setProperty('IsPlayable', 'true')

        # Gotham properly probes the mime type
        xbmcplugin.setResolvedUrl(handle=int(sys.argv[1]), succeeded=True, listitem=listItem)

def gozlan_play_video(url):
    name = url
    if ("name" in params):
      name=params["name"]
    image=""
    if ("image" in params):
      image=params["image"]
    description=""
    if "description" in params:  
      description=params["description"]
    
    ''' page=getData(base_domain+"/"+url,7)
    # <iframe src="http://www.putlocker.com/embed/F4988CE321910D0D" id='iframeinner'
    regexp='<iframe src="http://anonymouse.org/cgi-bin/anon-www.cgi/(.*?)"'
    media_url=re.compile('iframe src="http://anonymouse.org/cgi-bin/anon-www.cgi/(.*?)"',re.M+re.I+re.S).findall(page)[0]
    #addDir('test',media_url,9)
    print "Resolving URL: " + media_url
    videoPlayListUrl = urlresolver.HostedMediaFile(url=media_url).resolve()
    if not videoPlayListUrl:
      print "URL " + media_url + " could not have been resolved to a movie.\n"
      return'''
    #addon.resolve_url(stream_url)
    #videoPlayListUrl = urllib.unquote(videoUrl[0])
    listItem = xbmcgui.ListItem(name, image, image, path=url) # + '|' + 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3')
    listItem.setInfo(type='Video', infoLabels={ "Title": name})
    listItem.setProperty('IsPlayable', 'true')
    print "video url " + url
    #xbmc.Player(xbmc.PLAYER_CORE_MPLAYER).play(videoPlayListUrl)
    xbmcplugin.setResolvedUrl(handle=int(sys.argv[1]), succeeded=True, listitem=listItem)

def add_streams(streams, name=None, logo=None):
    log_debug('add_streams', 2)
    log_debug('streams: %s' % streams, 3)
    log_debug('name: %s' % name, 3)
    log_debug('logo: %s' % logo, 3)

    pDialog = xbmcgui.DialogProgress()
    pDialog.create(__addonname__, 'Creating playlist')
    playlist = xbmc.PlayList(xbmc.PLAYLIST_MUSIC)
    playlist.clear()
    for count, stream in enumerate(streams):
        log_debug('Adding stream %s to playlist.' % stream, 1)
        pDialog.update(50, 'Adding stream %d of %d to playlist' % (count + 1, len(streams)), stream)

        if name:
            liz = xbmcgui.ListItem(name, iconImage=logo, thumbnailImage=logo)
            liz.setInfo('music', {'Title': name})
            playlist.add(url=stream, listitem=liz)
        else:
            playlist.add(url=stream)
    pDialog.close()
    if len(playlist) > 0:
        xbmcplugin.setResolvedUrl(handle=int(__settings__.get_argv(1)), succeeded=True, listitem=playlist[0])
    else:
        xbmcplugin.setResolvedUrl(handle=int(__settings__.get_argv(1)), succeeded=False, listitem=None)

def PLAY(name,url):
	listitem = xbmcgui.ListItem(path=url)
	xbmc.log('### SETRESOLVEDURL ###')
	listitem.setProperty('IsPlayable', 'true')
	xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, listitem)
	xbmc.log('URL: ' + str(url), level=xbmc.LOGDEBUG)
	xbmcplugin.endOfDirectory(addon_handle)

def BGPlayvid(url, name, download=None):
    videopage = utils.getHtml2(url)
    videopage = json.loads(videopage)
    
    if not videopage["240p"] == None:
        url = videopage["240p"].encode("utf8")
    if not videopage["480p"] == None:
        url = videopage["480p"].encode("utf8")
    if not videopage["720p"] == None:
        url = videopage["720p"].encode("utf8")

    url = url.replace("{DATA_MARKERS}","data=pc.XX")
    if not url.startswith("http:"): url = "http:" + url
    videourl = url

    if download == 1:
        utils.downloadVideo(videourl, name)
    else:
        iconimage = xbmc.getInfoImage("ListItem.Thumb")
        listitem = xbmcgui.ListItem(name, iconImage="DefaultVideo.png", thumbnailImage=iconimage)
        listitem.setInfo('video', {'Title': name, 'Genre': 'Porn'})
        listitem.setProperty("IsPlayable","true")
        if int(sys.argv[1]) == -1:
            pl = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
            pl.clear()
            pl.add(videourl, listitem)
            xbmc.Player().play(pl)
        else:
            listitem.setPath(str(videourl))
            xbmcplugin.setResolvedUrl(utils.addon_handle, True, listitem)

def BGPlayvid(url, name, download=None):
    videopage = utils.getHtml(url, "")
    videopage = json.loads(videopage)

    if not videopage["240p"] == None:
        url = videopage["240p"].encode("utf8")
    if not videopage["480p"] == None:
        url = videopage["480p"].encode("utf8")
    if not videopage["720p"] == None:
        url = videopage["720p"].encode("utf8")

    url = url.replace("{DATA_MARKERS}", "data=pc.DE")
    if not url.startswith("http:"):
        url = "https:" + url

    key = re.compile("/key=(.*?)%2Cend", re.DOTALL | re.IGNORECASE).findall(url)[0]
    decryptedkey = decrypt_key(key)

    videourl = url.replace(key, decryptedkey)

    if download == 1:
        utils.downloadVideo(videourl, name)
    else:
        iconimage = xbmc.getInfoImage("ListItem.Thumb")
        listitem = xbmcgui.ListItem(name, iconImage="DefaultVideo.png", thumbnailImage=iconimage)
        listitem.setInfo("video", {"Title": name, "Genre": "Porn"})
        listitem.setProperty("IsPlayable", "true")
        if int(sys.argv[1]) == -1:
            pl = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
            pl.clear()
            pl.add(videourl, listitem)
            xbmc.Player().play(pl)
        else:
            listitem.setPath(str(videourl))
            xbmcplugin.setResolvedUrl(utils.addon_handle, True, listitem)

def resolve_url(url):
    content = make_request(url)
    if "chiasenhac" in url:
        try:
            media_url = (
                re.compile('"hd-2".+?"([^"]+)"')
                .findall(content)[0]
                .replace("%3A", ":")
                .replace("%2F", "/")
                .replace("%2520", "%20")
            )
        except:
            media_url = (
                re.compile('"file".*?"([^"]*)"')
                .findall(content)[-1]
                .replace("%3A", ":")
                .replace("%2F", "/")
                .replace("%2520", "%20")
            )
    elif "nhaccuatui" in url:
        media_url = re.compile('title=".+?" href="([^"]*)"').findall(content)[0]
    elif "timkaraoke" in url:
        media_url = re.compile('source src="(.+?)"').findall(content)[0].replace(" ", "%20")
    elif "thuynga" in url:
        media_url = re.compile("var iosUrl = '(.+?)'").findall(content)[0]
    else:
        media_url = url
    item = xbmcgui.ListItem(name, path=media_url)
    xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item)
    return

def GETMULTI(name,url,iconimage):
        streamurl=[]
        streamname=[]
        streamicon=[]
        link=open_url(url)
        link=re.sub(r'\(.*\)', '', link)
        name=re.sub(r'\(.*\)', '', name)
        urls=re.compile('<item>.+?<title>'+name+'</title>(.+?)</item>',re.DOTALL).findall(link)[0]
        iconimage=re.compile('<thumbnail>(.+?)</thumbnail>').findall(urls)[0]
        links=re.compile('<link>(.+?)</link>').findall(urls)
        i=1
        for sturl in links:
                streamurl.append( sturl )
                streamname.append( 'Link '+str(i) )
                dialog = xbmcgui.Dialog()
                i=i+1
        select = dialog.select(name,streamname)
        if select == -1:
                quit()
        else:
                url = streamurl[select]
                ok=True
                liz=xbmcgui.ListItem(name, iconImage=iconimage,thumbnailImage=iconimage); liz.setInfo( type="Video", infoLabels={ "Title": name } )
                ok=xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=url,listitem=liz)
                liz.setPath(url)
                xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, liz)