def run(self):
 
     for description in self.descriptions:
 
         common.log('[Rytec EPG Downloader]: '+description)
         self.i += self.upd
         self.progress('update', self.i, 'Rytec EPG Downloader', description, 'Downloading XML Data')
         ret = False
         epg_url = self.get_epg_url(description)
         
         if epg_url:
             ret = self.download_epg(description, epg_url)
             
         if not ret and not description.startswith('http'):
             self.run_rytec(description)
             
     self.progress('update', 70, 'Merging XML Data', ' ', 'Please Wait...This May Take Awhile')
             
     if self.len_desc > 1:
         common.merge_epg()
         self.progress('update', 90, 'Merging XML Data', ' ', 'Please Wait...This May Take Awhile')
         common.copy_temp_merged()
         common.delete_temp_merged()
     
     self.progress('close', '', '', '', '')

    def _check_excluded_files(self, filename):
        for ext in common.getaddon_setting("picsexcl").lower().split("|"):
            if ext in filename.lower() and len(ext)>0:
                common.log("VFSScanner._check_excluded_files", 'Picture "%s" excluded due to exclude condition "%s"'%(filename , common.getaddon_setting("picsexcl")) )
                return False

        return True

def getSteamExePath():
        import errno, sys, _winreg
        steamExe = ''

        try:
            if sys.maxsize > 2**32:
                arch_keys = {_winreg.KEY_WOW64_32KEY, _winreg.KEY_WOW64_64KEY}
            else:
                arch_keys = {_winreg.KEY_READ}

            for arch_key in arch_keys:

                key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Valve\Steam", 0, _winreg.KEY_READ | arch_key)
                try:
                    steamExe = _winreg.QueryValueEx(key, 'InstallPath')[0] + "\\steam.exe"
                except OSError as e:
                    if e.errno == errno.ENOENT:
                        # DisplayName doesn't exist in this skey
                        pass
                finally:
                    key.Close()
        except Exception,e:
            log(e.message)
            log(e.__class__.__name__)
            traceback.print_exc(e)

def start(background=False):
    global Resumes
    global Birth
    # ディレクトリをチェック
    if not os.path.isdir(common.cache_path): os.makedirs(common.cache_path)
    if not os.path.isdir(common.media_path): os.makedirs(common.media_path)
    if not os.path.isdir(common.data_path):  os.makedirs(common.data_path)
    # 初期化
    if os.path.isfile(common.settings_file) and getAlive():
        data = proceed()
    else:
        data = initialize()
    # 表示
    if not background: data.showPrograms()
    # Birth設定
    Birth = setBirth()
    # Alive設定を更新
    setAlive()
    # 更新
    monitor = Monitor()
    while not monitor.abortRequested():
        if monitor.waitForAbort(common.check_interval):
            log('break by aborted')
            clearResumes();
            break
        if not getBirth():
            log('break by renewed')
            break
        # common.check_interval毎に実行
        data = watcher(data)
        # Alive設定を更新
        setAlive()

def setup(radiru, radiko, jcba, misc):
    # テンプレート読み込み
    f = codecs.open(common.template_file,'r','utf-8')
    template = f.read()
    f.close()
    # 放送局リスト
    s = [common.addon.getLocalizedString(30520)]
    stations = Data((radiru,radiko)).stations
    for station in stations:
        s.append(station['name'])
    # ソース作成
    ffmpeg = '/usr/local/bin/ffmpeg'
    if not os.path.isfile(ffmpeg): ffmpeg = ''
    rtmpdump = '/usr/local/bin/rtmpdump'
    if not os.path.isfile(rtmpdump): rtmpdump = ''
    source = template.format(
        radiru = radiru.getSettingsData(),
        radiko = radiko.getSettingsData(),
        jcba   = jcba.getSettingsData(),
        misc   = misc.getSettingsData(),
        bc = '|'.join(s),
        ffmegpath = ffmpeg,
        rtmpdumppath = rtmpdump,
        os = platform.system())
    # ファイル書き込み
    f = codecs.open(common.settings_file,'w','utf-8')
    f.write(source)
    f.close()
    # ログ
    log('settings updated')

    def _countfiles(self, path, reset = True, recursive = True):
        if reset:
            self.totalfiles = 0
        
        common.log("VFSScanner._countfiles", 'path "%s"'%path)
        (_, files) = self.filescanner.walk(path, recursive, self.picture_extensions if self.use_videos == "false" else self.all_extensions)
        self.totalfiles += len(files)

        return self.totalfiles

    def dispatcher(self, options):

        self.options = options

        if self.options.rootpath:
            self.options.rootpath = common.smart_utf8(unquote_plus( self.options.rootpath)).replace("\\\\", "\\").replace("\\\\", "\\").replace("\\'", "\'")
            common.log("VFSScanner.dispatcher", 'Adding path "%s"'%self.options.rootpath, xbmc.LOGNOTICE)
            self.scan = AddonScan()
            self.action = common.getstring(30244)#adding
            self.scan.create( common.getstring(30000) )
            self.current_root_entry = 1
            self.total_root_entries = 1
            self.scan.update(0,0,
                        common.getstring(30000)+" ["+common.getstring(30241)+"]",#MyPicture Database [preparing]
                        common.getstring(30247))#please wait...
            
            self._countfiles(self.options.rootpath)
            self.total_root_entries = 1
            self._addpath(self.options.rootpath, None, self.options.recursive, True)
            
            self.scan.close()

        elif self.options.database or self.options.refresh:
            paths = self.mpdb.get_all_root_folders()
            common.log("VFSScanner.dispatcher", "Database refresh started", xbmc.LOGNOTICE)
            self.action = common.getstring(30242)#Updating
            if paths:
                self.scan = AddonScan()
                self.scan.create( common.getstring(30000) )
                self.current_root_entry = 0
                self.total_root_entries = 0
                self.scan.update(0,0,
                            common.getstring(30000)+" ["+common.getstring(30241)+"]",#MyPicture Database [preparing]
                            common.getstring(30247))#please wait...
                for path,recursive,update,exclude in paths:
                    if exclude==0:
                        self.total_root_entries += 1
                        self._countfiles(path,False)

                for path,recursive,update,exclude in paths:
                    if exclude==0:
                        try:
                            self.current_root_entry += 1
                            self._addpath(path, None, recursive, update)
                        except:
                            print_exc()

                self.scan.close()

        # Set default translation for tag types
        self.mpdb.default_tagtypes_translation()
        self.mpdb.cleanup_keywords()

        # delete all entries with "sha is null"
        self.picsdeleted += self.mpdb.del_pics_wo_sha(self.scan_is_cancelled)

        common.show_notification(common.getstring(30000), common.getstring(30248)%(self.picsscanned,self.picsadded,self.picsdeleted,self.picsupdated) )

 def download_epg(self, description, epg_url):
 
     ret = common.load_local_xml(epg_url)
     if ret:
         common.log('[Rytec EPG Downloader]: no epg update needed')
     else:
         if description.startswith('http'):
             if self.manual == True:
                 ret = rytec.download_epg(epg_url)
         if self.manual == False:
             ret = rytec.download_epg(epg_url)
             
     return ret

    def _get_xmp(self, fullpath):
        ###############################
        # get XMP infos               #
        ###############################
        tags = {}
        try:
            xmpclass = XMP_Tags()

            tags = xmpclass.get_xmp(os.path.dirname(fullpath), os.path.basename(fullpath))

        except Exception, msg:
            common.log("VFSScanner._get_xmp", 'Error reading XMP tags for "%s"'%(fullpath), xbmc.LOGERROR)
            common.log("VFSScanner._get_xmp",  "%s - %s"%(Exception,msg), xbmc.LOGERROR )

 def __init__(self):
     common.log("Service is starting...") 
     self.path = xbmc.translatePath('special://profile/addon_data/%s' %__id__ ) 
    
     #Checks if directory exists for file storage, if not it creates it
     if not xbmcvfs.exists(self.path):
         try:
             xbmcvfs.mkdir(self.path)
         except:
             pass
         
     self._reset = False
     self.monitor = MyMonitor(action=self.restart)
     self.start()

def list_artists():
    artist = None
    artist = common.enter_artist()
    artist = artist.decode('utf-8')
    common.log('[mvmixPlayer] artist entered: %s' % (artist.encode('utf-8')))
    if artist:
        addDir(artist.encode('utf-8').strip(),'play','','')
        from resources.lib import lastfm
        artists = lastfm.get_artists(artist)
        common.log('[mvmixPlayer] artists found: %s' % str(len(artists)))
        for a in artists:
            artist = a['artist'].encode('utf-8').strip()
            image = a['image']
            addDir(artist,'play',image,'')
        xbmcplugin.endOfDirectory(pluginhandle)

 def __init__(self, manual=False):
 
     common.log('[Rytec EPG Downloader]: rytec downloader started')
     self.manual       = manual
     self.sources_list = []
     self.i            = 0
     
     self.descriptions = common.get_descriptions()
     self.len_desc     = len(self.descriptions)
     if self.len_desc == 0:
         common.log('[Rytec EPG Downloader]: empty epg setting')
         return
     self.upd          = 60/self.len_desc
         
     self.progress('create', '', 'Rytec EPG Downloader', '', 'Downloading XML Data')
     self.run()

 def savePrograms(self):
     url = common.addon.getSetting('db')
     if url == '': return
     # 番組情報をDBへ送信
     programs = []
     for p in self.programs:
         if p['id'].find('radiru_') == 0: programs.append(p)
         if p['id'].find('radiko_') == 0: programs.append(p)
     data = {}
     data['programs'] = json.dumps(programs)
     response = urllib2.urlopen(url, urllib.urlencode(data))
     status = response.getcode()
     if status == 200:
         status1 = response.read()
         response.close()
         log('db status: ', status1)
     else:
         log('http error: ', status)

def refresh():
    global Resumes
    # カレントウィンドウをチェック
    immediate = False
    if xbmcgui.getCurrentWindowDialogId() == 9999:
        path = xbmc.getInfoLabel('Container.FolderPath')
        if path == sys.argv[0] and common.addon.getSetting('download') == 'false':
            immediate = True
        elif path == '%s?action=showPrograms' % sys.argv[0]:
            immediate = True

    # 画面を更新
    if immediate:
        xbmc.executebuiltin('Container.Update(%s?action=showPrograms,replace)' % (sys.argv[0]))
        Resumes['update'] = False
        log('update immediately')
    else:
        Resumes['update'] = True
        log('update scheduled')
    return immediate

 def onWatched(self):
     now = datetime.datetime.now()
     for m in self.matched_programs:
         # 開始直前であれば保存処理を開始
         wait = m['start'] - now
         if wait.days == 0 and wait.seconds < common.prep_interval:
             p = m['program']
             status = Downloads().add(
                 id=p['id'],
                 name=p['name'],
                 start=p['ft'],
                 end=p['to'],
                 title=p['title'],
                 description=p['description'],
                 source=p['source'],
                 lag=p['lag'],
                 key=m['key'])
             if status:
                 pass
             else:
                 log('start=',strptime(p['ft'],'%Y%m%d%H%M%S'),' name=',p['name'],' title=',p['title'])

    def _get_iptc(self, fullpath):

        try:
            info = IPTCInfo(fullpath)
        except Exception,msg:
            if not type(msg.args[0])==type(int()):
                if msg.args[0].startswith("No IPTC data found."):
                    return {}
                else:
                    common.log("VFSScanner._get_iptc", "%s"%fullpath )
                    common.log("VFSScanner._get_iptc", "%s - %s"%(Exception,msg) )
                    return {}
            else:
                common.log("VFSScanner._get_iptc", "%s"%fullpath )
                common.log("VFSScanner._get_iptc", "%s - %s"%(Exception,msg) )
                return {}

    def __init__(self):

        self.exclude_folders    = []
        self.all_extensions     = []
        self.picture_extensions = []
        self.video_extensions   = []
        self.lists_separator = "||"
        
        self.scan_is_cancelled = False
        
        self.picsdeleted = 0
        self.picsupdated = 0
        self.picsadded   = 0
        self.picsscanned = 0
        self.current_root_entry = 0
        self.total_root_entries = 0
        self.totalfiles  = 0
        self.mpdb = MypicsDB.MyPictureDB()
         
        for path,_,_,exclude in self.mpdb.get_all_root_folders():
            if exclude:
                common.log("", 'Exclude path "%s" found '%common.smart_unicode(path[:len(path)-1]))
                self.exclude_folders.append(common.smart_unicode(path[:len(path)-1]))

        for ext in common.getaddon_setting("picsext").split("|"):
            self.picture_extensions.append("." + ext.replace(".","").upper())

        for ext in common.getaddon_setting("vidsext").split("|"):
            self.video_extensions.append("." + ext.replace(".","").upper())

        self.use_videos = common.getaddon_setting("usevids")

        self.all_extensions.extend(self.picture_extensions)
        self.all_extensions.extend(self.video_extensions)

        self.filescanner = Scanner()

import sys
import xbmc
import xbmcgui
import xbmcvfs
import xbmcplugin
import xbmcaddon

settings = xbmcaddon.Addon()
language = settings.getLocalizedString
plugin = settings.getAddonInfo('id')

if __name__ == '__main__':
    import resources.lib.common as common
    common.log('ARGV: ' + repr(sys.argv), common.INFO)

    try:
        import StorageServer
        cache = StorageServer.StorageServer(common.plugin,
            int(settings.getSetting('cache_time')))
    except ImportError:
        common.log("Common Plugin Cache isn't installed, using dummy class.")
        import storageserverdummy
        cache = storageserverdummy.StorageServer(common.plugin)

    from resources.lib.api import Api
    api = Api()

    import resources.lib.nav as nav
    nav.list_menu()

    def _get_exif(self, picfile):

        EXIF_fields =[
                    "Image Model",
                    "Image Orientation",
                    "Image Rating",
                    "Image RatingPercent",
					"Image Artist",
                    "GPS GPSLatitude",
                    "GPS GPSLatitudeRef",
                    "GPS GPSLongitude",
                    "GPS GPSLongitudeRef",
                    "Image DateTime",
                    "EXIF DateTimeOriginal",
                    "EXIF DateTimeDigitized",
                    "EXIF ExifImageWidth",
                    "EXIF ExifImageLength",
                    "EXIF Flash",
                    "Image ResolutionUnit",
                    "Image XResolution",
                    "Image YResolution",
                    "Image Make",
                    "EXIF FileSource",
                    "EXIF SceneCaptureType",
                    "EXIF DigitalZoomRatio",
                    "EXIF ExifVersion"
                      ]

        # try to open picfile in modify/write mode. Windows needs this for memory mapped file support.
        try:
            # General for all OS. Use unicode for picfile.
            # This fails with OpenElec or if modify/write attribute isn't set.
            f=open(picfile,"r+b")
            common.log( "VFSScanner._get_exif()", 'File opened with statement: %s'%'f=open(picfile,"r+b")')
        except:
            try:
                # Special for OpenElec. Use utf-8 for picfile.
                # If modify/write attribute isn't set then it'll fail.
                f=open(picfile.encode("utf-8"),"r+b")
                common.log( "VFSScanner._get_exif()", 'File opened with statement: %s'%'f=open(picfile.encode("utf-8"),"r+b")')
            except:
                # Where're here because write/modify attribute is missing and file could not be opened.
                try:
                    # General for all OS. Use unicode for picfile.
                    f=open(picfile,"rb")
                    common.log( "VFSScanner._get_exif()", 'File opened with statement: %s'%'f=open(picfile,"rb")')
                except:
                    # Special for OpenElec. Use utf-8 for picfile.
                    f=open(picfile.encode('utf-8'),"rb")
                    common.log( "VFSScanner._get_exif()", 'File opened with statement: %s'%'f=open(picfile.encode("utf-8"),"rb")')
        common.log( "VFSScanner._get_exif()", 'Calling function EXIF_file for "%s"'%picfile)

        mmapfile = 0
        try:
            # If write/modify attribute isn't set then this will fail on Windows because above the file was opened read only!
            mmapfile = mmap.mmap(f.fileno(), 0)
            tags = EXIF_file(mmapfile, details=False)
            common.log( "VFSScanner._get_exif()", 'EXIF_file with mmap support returned')
        except:
            try:
                # We've to open the file without memory mapped file support.
                tags = EXIF_file(f, details=False)
                common.log( "VFSScanner._get_exif()", 'EXIF_file without mmap support returned')
            except Exception,msg:
                common.log("VFSScanner._get_exif", picfile , xbmc.LOGERROR)
                common.log("VFSScanner._get_exif", "%s - %s"%(Exception,msg), xbmc.LOGERROR )

    def _get_metas(self, fullpath):
        picentry = {}
        extension = os.path.splitext(fullpath)[1].upper()
        if extension in self.picture_extensions:
            ###############################
            #    getting  EXIF  infos     #
            ###############################
            try:
                common.log( "VFSScanner._get_metas()._get_exif()", 'Reading EXIF tags from "%s"'%fullpath)
                exif = self._get_exif(fullpath)
                picentry.update(exif)
                common.log( "VFSScanner._get_metas()._get_exif()", "Finished reading EXIF tags")
            except Exception,msg:
                common.log( "VFSScanner._get_metas()._get_exif()", "Exception", xbmc.LOGERROR)
                common.log( "VFSScanner._get_metas()._get_exif()", msg, xbmc.LOGERROR)


            ###############################
            #    getting  IPTC  infos     #
            ###############################
            try:
                common.log( "VFSScanner._get_metas()._get_iptc()", 'Reading IPTC tags from "%s"'%fullpath)
                iptc = self._get_iptc(fullpath)
                picentry.update(iptc)
                common.log( "VFSScanner._get_metas()._get_iptc()", "Finished reading IPTC tags")
            except Exception,msg:
                common.log( "VFSScanner._get_metas()_get_iptc()", "Exception", xbmc.LOGERROR)
                common.log( "VFSScanner._get_metas()._get_iptc()", msg, xbmc.LOGERROR)