def _doesThemeExist(self, directory):
log("doesThemeExist: Checking directory: %s" % directory)
# Check for custom theme directory
if Settings.isThemeDirEnabled():
themeDir = os_path_join(directory, Settings.getThemeDirectory())
# Check if this directory exists
if not dir_exists(themeDir):
workingPath = directory
# If the path currently ends in the directory separator
# then we need to clear an extra one
if (workingPath[-1] == os.sep) or (workingPath[-1]
== os.altsep):
workingPath = workingPath[:-1]
# If not check to see if we have a DVD VOB
if (os_path_split(workingPath)[1]
== 'VIDEO_TS') or (os_path_split(workingPath)[1]
== 'BDMV'):
# Check the parent of the DVD Dir
themeDir = os_path_split(workingPath)[0]
themeDir = os_path_join(themeDir,
Settings.getThemeDirectory())
directory = themeDir
# check if the directory exists before searching
if dir_exists(directory):
# Generate the regex
themeFileRegEx = Settings.getThemeFileRegEx(audioOnly=True)
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(themeFileRegEx, aFile, re.IGNORECASE)
if m:
log("doesThemeExist: Found match: " + aFile)
return True
return False
def getPlatformLibFiles(parentDir):
if parentDir in [None, ""]:
return None
log("FFMpegLib: Looking for libraries in %s" % parentDir)
libLocation = {}
# Check if the directory exists
if dir_exists(parentDir):
# List the contents of the directory
dirs, files = xbmcvfs.listdir(parentDir)
for aFile in files:
if 'avutil' in aFile:
libLocation['avutil'] = os_path_join(parentDir, aFile)
log("FFMpegLib: Found avutil library: %s" % libLocation['avutil'])
elif 'swresample' in aFile:
libLocation['swresample'] = os_path_join(parentDir, aFile)
log("FFMpegLib: Found swresample library: %s" % libLocation['swresample'])
elif 'avcodec' in aFile:
libLocation['avcodec'] = os_path_join(parentDir, aFile)
log("FFMpegLib: Found avcodec library: %s" % libLocation['avcodec'])
elif 'avformat' in aFile:
libLocation['avformat'] = os_path_join(parentDir, aFile)
log("FFMpegLib: Found avformat library: %s" % libLocation['avformat'])
else:
log("FFMpegLib: Directory not found %s" % parentDir)
# Make sure we found all of the libraries
if len(libLocation) < 4:
return None
return libLocation
def _moveToThemeFolder(self, directory):
log("moveToThemeFolder: path = %s" % directory)
# Handle the case where we have a disk image
if (os_path_split(directory)[1] == 'VIDEO_TS') or (os_path_split(directory)[1] == 'BDMV'):
directory = os_path_split(directory)[0]
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(Settings.getThemeFileRegEx(directory), aFile, re.IGNORECASE)
if m:
srcpath = os_path_join(directory, aFile)
log("fetchAllMissingThemes: Found match: %s" % srcpath)
targetpath = os_path_join(directory, Settings.getThemeDirectory())
# Make sure the theme directory exists
if not dir_exists(targetpath):
try:
xbmcvfs.mkdir(targetpath)
except:
log("fetchAllMissingThemes: Failed to create directory: %s" % targetpath, True, xbmc.LOGERROR)
break
else:
log("moveToThemeFolder: directory already exists %s" % targetpath)
# Add the filename to the path
targetpath = os_path_join(targetpath, aFile)
if not xbmcvfs.rename(srcpath, targetpath):
log("moveToThemeFolder: Failed to move file from %s to %s" % (srcpath, targetpath))
def _doesThemeExist(self, directory):
log("doesThemeExist: Checking directory: %s" % directory)
# Check for custom theme directory
if Settings.isThemeDirEnabled():
themeDir = os_path_join(directory, Settings.getThemeDirectory())
# Check if this directory exists
if not dir_exists(themeDir):
workingPath = directory
# If the path currently ends in the directory separator
# then we need to clear an extra one
if (workingPath[-1] == os.sep) or (workingPath[-1] == os.altsep):
workingPath = workingPath[:-1]
# If not check to see if we have a DVD VOB
if (os_path_split(workingPath)[1] == 'VIDEO_TS') or (os_path_split(workingPath)[1] == 'BDMV'):
# Check the parent of the DVD Dir
themeDir = os_path_split(workingPath)[0]
themeDir = os_path_join(themeDir, Settings.getThemeDirectory())
directory = themeDir
# check if the directory exists before searching
if dir_exists(directory):
# Generate the regex
themeFileRegEx = Settings.getThemeFileRegEx(audioOnly=True)
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(themeFileRegEx, aFile, re.IGNORECASE)
if m:
log("doesThemeExist: Found match: " + aFile)
return True
return False
def _getExtrasDirFiles(self,
basepath,
exitOnFirst=False,
noExtrasDirNeeded=False):
# If a custom path, then don't looks for the Extras directory
if noExtrasDirNeeded or Settings.isCustomPathEnabled():
extrasDir = basepath
else:
# Add the name of the extras directory to the end of the path
extrasDir = os_path_join(basepath, Settings.getExtrasDirName())
log("VideoExtrasFinder: Checking existence for %s" % extrasDir)
extras = []
# Check if the extras directory exists
if dir_exists(extrasDir):
# list everything in the extras directory
dirs, files = xbmcvfs.listdir(extrasDir)
for filename in files:
log("VideoExtrasFinder: found file: %s" % filename)
# Check each file in the directory to see if it should be skipped
if not self._shouldSkipFile(filename):
extrasFile = os_path_join(extrasDir, filename)
extraItem = ExtrasItem(extrasDir,
extrasFile,
extrasDb=self.extrasDb,
defaultFanArt=self.defaultFanArt)
extras.append(extraItem)
# Check if we are only looking for the first entry
if exitOnFirst is True:
break
# Now check all the directories in the "Extras" directory
# Need to see if they contain a DVD image
for dirName in dirs:
log("VideoExtrasFinder: found directory: %s" % dirName)
# Check each directory to see if it should be skipped
if not self._shouldSkipFile(dirName):
extrasSubDir = os_path_join(extrasDir, dirName)
# Check to see if this sub-directory is a DVD directory by checking
# to see if there is VIDEO_TS directory
videoTSDir = os_path_join(extrasSubDir, 'VIDEO_TS')
# Also check for Bluray
videoBluRayDir = os_path_join(extrasSubDir, 'BDMV')
if dir_exists(videoTSDir) or dir_exists(videoBluRayDir):
extraItem = ExtrasItem(
extrasDir,
extrasSubDir,
extrasDb=self.extrasDb,
defaultFanArt=self.defaultFanArt)
extras.append(extraItem)
# Check if we are only looking for the first entry
if exitOnFirst is True:
break
return extras
def _addFilesFromPlaylist(self, playlistFile, directory):
if (playlistFile is None) or (playlistFile == ""):
return
fileExt = os.path.splitext(playlistFile)[1]
# Check if dealing with a Smart Playlist
if fileExt == ".xsp":
# Process the Smart Playlist
self._addFilesFromSmartPlaylist(playlistFile)
return
if ("/" not in playlistFile) and ("\\" not in playlistFile):
# There is just the filename of the playlist without
# a path, check if the file is local or if we should
# read it from the user directory
# Check if there is an extension on the name
if fileExt is None or fileExt == "":
playlistFile = playlistFile + ".m3u"
localFile = os_path_join(directory, playlistFile)
if xbmcvfs.exists(localFile):
# Make it a full path if it is not already
playlistFile = localFile
else:
# default to the music playlist directory if not local
playlistFile = os_path_join(
xbmc.translatePath("special://musicplaylists"),
playlistFile)
log("NfoReader: playlist file = %s" % playlistFile,
self.debug_logging_enabled)
if xbmcvfs.exists(playlistFile):
# Load the playlist into the Playlist object
# An exception if thrown if the file does not exist
try:
xbmcPlaylist = xbmc.PlayList(xbmc.PLAYLIST_MUSIC)
xbmcPlaylist.load(playlistFile)
i = 0
while i < xbmcPlaylist.size():
# get the filename from the playlist
file = xbmcPlaylist[i].getfilename()
i = i + 1
if (file is not None) and (file != ""):
log("NfoReader: file from playlist = %s" % file,
self.debug_logging_enabled)
self.themeFiles.append(file)
except:
log(
"NfoReader: playlist file processing error = %s" %
playlistFile, True, xbmc.LOGERROR)
else:
log("NfoReader: playlist file not found = %s" % playlistFile,
self.debug_logging_enabled)
def __init__(self):
addonRootDir = xbmc.translatePath("special://profile/addon_data/%s" % __addonid__).decode("utf-8")
self.tempDir = os_path_join(addonRootDir, "temp")
self.videoDir = os_path_join(addonRootDir, "videos")
# Set up the addon directories if they do not already exist
if not dir_exists(addonRootDir):
xbmcvfs.mkdir(addonRootDir)
if not dir_exists(self.tempDir):
xbmcvfs.mkdir(self.tempDir)
if not dir_exists(self.videoDir):
xbmcvfs.mkdir(self.videoDir)
def _loadImages(self, filename):
imageList = []
# Find out the name of the image files
fileNoExt = os.path.splitext(filename)[0]
# Start by searching for the filename match
fileNoExtImage = self._loadImageFile(fileNoExt)
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
# Check for -poster added to the end
fileNoExtImage = self._loadImageFile(fileNoExt + "-poster")
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
if len(imageList) < 2:
# Check for -thumb added to the end
fileNoExtImage = self._loadImageFile(fileNoExt + "-thumb")
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
if len(imageList) < 2:
# Check for poster.jpg
fileDir = os_path_join(self.directory, "poster")
fileNoExtImage = self._loadImageFile(fileDir)
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
if len(imageList) < 2:
# Check for folder.jpg
fileDir = os_path_join(self.directory, "folder")
fileNoExtImage = self._loadImageFile(fileDir)
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
# Set the first one to the thumbnail, and the second the the icon
if len(imageList) > 0:
self.thumbnailImage = imageList[0]
if len(imageList) > 1:
self.iconImage = imageList[1]
# Now check for the fanart
# Check for -fanart added to the end
fileNoExtImage = self._loadImageFile(fileNoExt + "-fanart")
if fileNoExtImage != "":
self.fanart = fileNoExtImage
else:
# Check for fanart.jpg
fileDir = os_path_join(self.directory, "fanart")
fileNoExtImage = self._loadImageFile(fileDir)
if fileNoExtImage != "":
self.fanart = fileNoExtImage
def _loadImages(self, filename):
imageList = []
# Find out the name of the image files
fileNoExt = os.path.splitext(filename)[0]
# Start by searching for the filename match
fileNoExtImage = self._loadImageFile(fileNoExt)
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
# Check for -poster added to the end
fileNoExtImage = self._loadImageFile(fileNoExt + "-poster")
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
if len(imageList) < 2:
# Check for -thumb added to the end
fileNoExtImage = self._loadImageFile(fileNoExt + "-thumb")
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
if len(imageList) < 2:
# Check for poster.jpg
fileDir = os_path_join(self.directory, "poster")
fileNoExtImage = self._loadImageFile(fileDir)
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
if len(imageList) < 2:
# Check for folder.jpg
fileDir = os_path_join(self.directory, "folder")
fileNoExtImage = self._loadImageFile(fileDir)
if fileNoExtImage != "":
imageList.append(fileNoExtImage)
# Set the first one to the thumbnail, and the second the the icon
if len(imageList) > 0:
self.thumbnailImage = imageList[0]
if len(imageList) > 1:
self.iconImage = imageList[1]
# Now check for the fanart
# Check for -fanart added to the end
fileNoExtImage = self._loadImageFile(fileNoExt + "-fanart")
if fileNoExtImage != "":
self.fanart = fileNoExtImage
else:
# Check for fanart.jpg
fileDir = os_path_join(self.directory, "fanart")
fileNoExtImage = self._loadImageFile(fileDir)
if fileNoExtImage != "":
self.fanart = fileNoExtImage
def __init__(self):
addonRootDir = xbmc.translatePath('special://profile/addon_data/%s' % __addonid__).decode("utf-8")
self.tempDir = os_path_join(addonRootDir, 'temp')
self.videoDir = os_path_join(addonRootDir, 'videos')
self.ziggyServer = "aHR0cDovL2tvZGkuemlnZ3k3MzcwMS5zZWVkci5pby9WaWRlb1NjcmVlbnNhdmVyLw=="
# Set up the addon directories if they do not already exist
if not dir_exists(addonRootDir):
xbmcvfs.mkdir(addonRootDir)
if not dir_exists(self.tempDir):
xbmcvfs.mkdir(self.tempDir)
if not dir_exists(self.videoDir):
xbmcvfs.mkdir(self.videoDir)
def __init__(self):
addonRootDir = xbmc.translatePath('special://profile/addon_data/%s' %
__addonid__).decode("utf-8")
self.tempDir = os_path_join(addonRootDir, 'temp')
self.videoDir = os_path_join(addonRootDir, 'videos')
# Set up the addon directories if they do not already exist
if not dir_exists(addonRootDir):
xbmcvfs.mkdir(addonRootDir)
if not dir_exists(self.tempDir):
xbmcvfs.mkdir(self.tempDir)
if not dir_exists(self.videoDir):
xbmcvfs.mkdir(self.videoDir)
def _findCoverImage(self, dirPath):
coverImages = []
dirs, files = xbmcvfs.listdir(dirPath)
for aFile in files:
if aFile.startswith('cover') and (aFile.endswith('jpg') or aFile.endswith('jpeg') or aFile.endswith('png')):
# Add this image to the list
coverImages.append(os_path_join(dirPath, aFile))
# Now check any of the directories
for aDir in dirs:
coverImages = coverImages + self._findCoverImage(os_path_join(dirPath, aDir))
return coverImages
def __init__(self):
addonRootDir = xbmc.translatePath('special://profile/addon_data/%s' %
__addonid__).decode("utf-8")
self.tempDir = os_path_join(addonRootDir, 'temp')
self.videoDir = os_path_join(addonRootDir, 'videos')
self.ziggyServer = "aHR0cDovL2tvZGkuemlnZ3k3MzcwMS5zZWVkci5pby9WaWRlb1NjcmVlbnNhdmVyLw=="
# Set up the addon directories if they do not already exist
if not dir_exists(addonRootDir):
xbmcvfs.mkdir(addonRootDir)
if not dir_exists(self.tempDir):
xbmcvfs.mkdir(self.tempDir)
if not dir_exists(self.videoDir):
xbmcvfs.mkdir(self.videoDir)
def _findCoverImage(self, dirPath):
coverImages = []
dirs, files = xbmcvfs.listdir(dirPath)
for aFile in files:
if aFile.startswith('cover') and (aFile.endswith('jpg') or aFile.endswith('jpeg') or aFile.endswith('png')):
# Add this image to the list
coverImages.append(os_path_join(dirPath, aFile))
# Now check any of the directories
for aDir in dirs:
coverImages = coverImages + self._findCoverImage(os_path_join(dirPath, aDir))
return coverImages
def _getThemeFiles(self, directory, extensionOnly=False):
# First read from the NFO file if it exists
nfoRead = NfoReader(directory, self.debug_logging_enabled)
themeFiles = nfoRead.getThemeFiles()
# Get the theme directories that are referenced and process the data in them
for nfoDir in nfoRead.getThemeDirs():
# Do not want the theme keyword if looking at an entire directory
themeFiles = themeFiles + self._getThemeFiles(nfoDir, True)
del nfoRead
themeRegex = Settings.getThemeFileRegEx(directory, extensionOnly,
self.audioOnly)
log("ThemeFiles: Searching %s for %s" % (directory, themeRegex),
self.debug_logging_enabled)
# Make sure that the path does not point to a plugin, as we are checking the
# file-system for themes, not plugins. This can be the case with Emby
if "plugin://" in directory:
log(
"ThemeFiles: Plugin paths do not support theme files: %s" %
directory, self.debug_logging_enabled)
else:
# check if the directory exists before searching
if dir_exists(directory):
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(themeRegex, aFile, re.IGNORECASE)
if m:
path = os_path_join(directory, aFile)
log("ThemeFiles: Found match: %s" % path,
self.debug_logging_enabled)
# Add the theme file to the list
themeFiles.append(path)
# Check to see if any themes were found, and if not see if we should try
# and use a trailer file instead
if (len(themeFiles) < 1) and (not self.audioOnly) and (
not extensionOnly) and Settings.useTrailers():
trailerRegEx = Settings.getTrailerFileRegEx()
for aFile in files:
m = re.search(trailerRegEx, aFile, re.IGNORECASE)
if m:
path = os_path_join(directory, aFile)
log("ThemeFiles: Found trailer match: %s" % path,
self.debug_logging_enabled)
# Add the trailer file to the list
themeFiles.append(path)
return themeFiles
def _getExtrasDirFiles(self, basepath, exitOnFirst=False, noExtrasDirNeeded=False):
# If a custom path, then don't looks for the Extras directory
if noExtrasDirNeeded or Settings.isCustomPathEnabled():
extrasDir = basepath
else:
# Add the name of the extras directory to the end of the path
extrasDir = os_path_join(basepath, Settings.getExtrasDirName())
log("VideoExtrasFinder: Checking existence for %s" % extrasDir)
extras = []
# Check if the extras directory exists
if dir_exists(extrasDir):
# list everything in the extras directory
dirs, files = xbmcvfs.listdir(extrasDir)
for filename in files:
log("VideoExtrasFinder: found file: %s" % filename)
# Check each file in the directory to see if it should be skipped
if not self._shouldSkipFile(filename):
extrasFile = os_path_join(extrasDir, filename)
extraItem = ExtrasItem(extrasDir, extrasFile, extrasDb=self.extrasDb, defaultFanArt=self.defaultFanArt)
extras.append(extraItem)
# Check if we are only looking for the first entry
if exitOnFirst is True:
break
# Now check all the directories in the "Extras" directory
# Need to see if they contain a DVD image
for dirName in dirs:
log("VideoExtrasFinder: found directory: %s" % dirName)
# Check each directory to see if it should be skipped
if not self._shouldSkipFile(dirName):
extrasSubDir = os_path_join(extrasDir, dirName)
# Check to see if this sub-directory is a DVD directory by checking
# to see if there is VIDEO_TS directory
videoTSDir = os_path_join(extrasSubDir, 'VIDEO_TS')
# Also check for Bluray
videoBluRayDir = os_path_join(extrasSubDir, 'BDMV')
if dir_exists(videoTSDir) or dir_exists(videoBluRayDir):
extraItem = ExtrasItem(extrasDir, extrasSubDir, extrasDb=self.extrasDb, defaultFanArt=self.defaultFanArt)
extras.append(extraItem)
else:
# This is a sub directory inside the extras directory that is
# not a DVD image directory, so scan the contents of this as well
extras = extras + self._getExtrasDirFiles(extrasSubDir, exitOnFirst, True)
# Check if we are only looking for the first entry
if exitOnFirst is True:
break
return extras
def _findBookFile(self, dirPath, bookFileName):
bookFile = None
dirs, files = xbmcvfs.listdir(dirPath)
for aFile in files:
if aFile.lower() == bookFileName:
# Found a match, set the value
bookFile = os_path_join(dirPath, aFile)
break
# Now check any of the directories
for aDir in dirs:
if bookFile is None:
bookFile = self._findBookFile(os_path_join(dirPath, aDir), bookFileName)
return bookFile
def _getMainCoverLocation(self):
coverFileName, oldExt = os.path.splitext(self.fileName)
targetCoverName = "%s.jpg" % coverFileName
coverTargetName = os_path_join(Settings.getCoverCacheLocation(), targetCoverName)
log("AudioBookHandler: Cached cover target location is %s" % coverTargetName)
return coverTargetName
def getCoverImage(filePath, eBookFileName):
# Check if there is a cached version
coverTargetName = None
fullpathLocalImage, bookExt = os.path.splitext(filePath)
fullpathLocalImage = "%s.jpg" % fullpathLocalImage
if xbmcvfs.exists(fullpathLocalImage):
log("EBookBase: Found local cached image %s" % fullpathLocalImage)
return fullpathLocalImage
# Check for a cached cover
coverTargetName = EBookBase.getCachedCover(eBookFileName)
# If we reach here, then there was no cached cover image, so we need to extract one
if coverTargetName in [None, ""]:
ebook = EBookBase.createEBookObject(filePath)
coverTargetName = ebook.extractCoverImage()
ebook.tidyUp()
del ebook
# If there is still no cover image, check for folder.jpg in the same directory
if coverTargetName in [None, ""]:
baseDirectory = (os_path_split(filePath))[0]
subdirs, filesInDir = xbmcvfs.listdir(baseDirectory)
for fileInDir in filesInDir:
if fileInDir.lower() in ['folder.jpg', 'cover.jpg', 'folder.png', 'cover.png']:
coverTargetName = os_path_join(baseDirectory, fileInDir)
return coverTargetName
def _getNestedExtrasFiles(self, basepath, filename, exitOnFirst=False, noExtrasDirNeeded=False):
extras = []
if dir_exists(basepath):
dirs, files = xbmcvfs.listdir(basepath)
for dirname in dirs:
# Do not search inside Bluray or DVD images
if (dirname == 'VIDEO_TS') or (dirname == 'BDMV'):
continue
dirpath = os_path_join(basepath, dirname)
log("VideoExtrasFinder: Nested check in directory: %s" % dirpath)
if dirname != Settings.getExtrasDirName():
log("VideoExtrasFinder: Check directory: %s" % dirpath)
extras.extend(self._getExtrasDirFiles(dirpath, exitOnFirst, noExtrasDirNeeded))
# Check if we are only looking for the first entry
if files and (exitOnFirst is True):
break
extras.extend(self._getExtrasFiles(dirpath, filename, exitOnFirst))
# Check if we are only looking for the first entry
if files and (exitOnFirst is True):
break
extras.extend(self._getNestedExtrasFiles(dirpath, filename, exitOnFirst, noExtrasDirNeeded))
# Check if we are only looking for the first entry
if files and (exitOnFirst is True):
break
return extras
def _loadHashRecord(self, recordLocation):
log("AddonData: Loading hash record %s" % recordLocation)
hashFile = os_path_join(recordLocation, 'hashdata.xml')
addonList = {}
if not xbmcvfs.exists(hashFile):
log("AddonData: Unable to load as file does not exist %s" % hashFile)
return addonList
try:
recordFile = xbmcvfs.File(hashFile, 'r')
recordFileStr = recordFile.read()
recordFile.close()
hashRecord = ET.ElementTree(ET.fromstring(recordFileStr))
for elemItem in hashRecord.findall('addon'):
hashDetails = {}
addonName = elemItem.attrib['name']
hashDetails['name'] = addonName
hashDetails['version'] = elemItem.attrib['version']
hashDetails['hash'] = elemItem.text
log("AddonData: Processing entry %s (%s) with hash %s" % (hashDetails['name'], hashDetails['version'], hashDetails['hash']))
addonList[addonName] = hashDetails
except:
log("AddonData: Failed to read in file %s" % hashFile, xbmc.LOGERROR)
log("AddonData: %s" % traceback.format_exc(), xbmc.LOGERROR)
return addonList
def _findTocNcx(self, dirPath):
tocNcx = None
dirs, files = xbmcvfs.listdir(dirPath)
for aFile in files:
if aFile.lower() == 'toc.ncx':
# Found the table of contents file
tocNcx = os_path_join(dirPath, aFile)
break
# Now check any of the directories
for aDir in dirs:
if tocNcx is None:
tocNcx = self._findTocNcx(os_path_join(dirPath, aDir))
return tocNcx
def __init__(self):
# Start by getting the database location
self.configPath = xbmc.translatePath(__addon__.getAddonInfo('profile'))
self.databasefile = os_path_join(self.configPath, "pinsentry_database.db")
log("PinSentryDB: Database file location = %s" % self.databasefile)
# Make sure that the database exists if this is the first time
self.createDatabase()
def __init__(self, rawPath, pathList=None, videotitle=None, debug_logging_enabled=True, audioOnly=False):
self.debug_logging_enabled = debug_logging_enabled
self.forceShuffle = False
self.doNotShuffle = False
self.audioOnly = audioOnly
self.rawPath = rawPath
if rawPath in [None, ""]:
self.clear()
else:
# Check for the case where there is a custom path set so we need to use
# the custom location rather than the rawPath
if Settings.isCustomPathEnabled() and (videotitle not in [None, ""]):
customRoot = Settings.getCustomPath()
# Make sure that the path passed in has not already been converted
if customRoot not in self.rawPath:
self.rawPath = os_path_join(customRoot, normalize_string(videotitle))
log("ThemeFiles: Setting custom path to %s" % self.rawPath, self.debug_logging_enabled)
if (pathList is not None) and (len(pathList) > 0):
self.themeFiles = []
for aPath in pathList:
subThemeList = self._generateThemeFilelistWithDirs(aPath)
# add these files to the existing list
self.themeFiles = self._mergeThemeLists(self.themeFiles, subThemeList)
# If we were given a list, then we should shuffle the themes
# as we don't always want the first path playing first
self.forceShuffle = True
else:
self.themeFiles = self._generateThemeFilelistWithDirs(self.rawPath)
# Check if we need to handle the ordering for video themes
if not audioOnly:
self.doNotShuffle = self._filterForVideoThemesRule()
self.forceShuffle = False
def _findBookFile(self, dirPath, bookFileName):
bookFile = None
dirs, files = xbmcvfs.listdir(dirPath)
for aFile in files:
if aFile.lower() == bookFileName:
# Found a match, set the value
bookFile = os_path_join(dirPath, aFile)
break
# Now check any of the directories
for aDir in dirs:
if bookFile is None:
bookFile = self._findBookFile(os_path_join(dirPath, aDir), bookFileName)
return bookFile
def _getExtrasFiles(self, filepath, filename, exitOnFirst=False):
extras = []
extrasTag = Settings.getExtrasFileTag()
# If there was no filename given, nothing to do
if (filename is None) or (filename == "") or (extrasTag == ""):
return extras
directory = filepath
dirs, files = xbmcvfs.listdir(directory)
for aFile in files:
if not self._shouldSkipFile(aFile) and (
extrasTag in aFile
) and aFile.startswith(os.path.splitext(filename)[0] + extrasTag):
extrasFile = os_path_join(directory, aFile)
extraItem = ExtrasItem(directory,
extrasFile,
True,
extrasDb=self.extrasDb,
defaultFanArt=self.defaultFanArt)
extras.append(extraItem)
# Check if we are only looking for the first entry
if exitOnFirst is True:
break
return extras
def _getThemeFiles(self, directory, extensionOnly=False):
# First read from the NFO file if it exists
nfoRead = NfoReader(directory, self.debug_logging_enabled)
themeFiles = nfoRead.getThemeFiles()
# Get the theme directories that are referenced and process the data in them
for nfoDir in nfoRead.getThemeDirs():
# Do not want the theme keyword if looking at an entire directory
themeFiles = themeFiles + self._getThemeFiles(nfoDir, True)
del nfoRead
log("ThemeFiles: Searching %s for %s" % (directory, Settings.getThemeFileRegEx(directory, extensionOnly, self.audioOnly)), self.debug_logging_enabled)
# check if the directory exists before searching
if dir_exists(directory):
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(Settings.getThemeFileRegEx(directory, extensionOnly, self.audioOnly), aFile, re.IGNORECASE)
if m:
path = os_path_join(directory, aFile)
log("ThemeFiles: Found match: %s" % path, self.debug_logging_enabled)
# Add the theme file to the list
themeFiles.append(path)
return themeFiles
def _findTocNcx(self, dirPath):
tocNcx = None
dirs, files = xbmcvfs.listdir(dirPath)
for aFile in files:
if aFile.lower() == 'toc.ncx':
# Found the table of contents file
tocNcx = os_path_join(dirPath, aFile)
break
# Now check any of the directories
for aDir in dirs:
if tocNcx is None:
tocNcx = self._findTocNcx(os_path_join(dirPath, aDir))
return tocNcx
def _generateThemeFilelist(self, rawPath):
# Get the full path with any network alterations
workingPath = self._getUsablePath(rawPath)
themeList = self._getThemeFiles(workingPath)
# If no themes have been found
if len(themeList) < 1:
# TV shows stored as ripped disc folders
if ('VIDEO_TS' in workingPath) or ('BDMV' in workingPath):
log("ThemeFiles: Found VIDEO_TS or BDMV in path: Correcting the path for DVDR tv shows", self.debug_logging_enabled)
workingPath = os_path_split(workingPath)[0]
themeList = self._getThemeFiles(workingPath)
if len(themeList) < 1:
workingPath = os_path_split(workingPath)[0]
themeList = self._getThemeFiles(workingPath)
else:
# If no theme files were found in this path, look at the parent directory
workingPath = os_path_split(workingPath)[0]
# Check for the case where there is the theme forlder settings, we want to
# check the parent folders themes directory
if Settings.isThemeDirEnabled():
themeDir = os_path_join(workingPath, Settings.getThemeDirectory())
themeList = self._getThemeFiles(themeDir)
# If there are still no themes, just check the parent directory
if len(themeList) < 1:
themeList = self._getThemeFiles(workingPath)
log("ThemeFiles: Playlist size = %d" % len(themeList), self.debug_logging_enabled)
log("ThemeFiles: Working Path = %s" % workingPath, self.debug_logging_enabled)
return themeList
def getVOBFile(self):
# Check to see if the filename actually holds a directory
# If that is the case, we will only support it being a DVD Directory Image
# So check to see if the expected file is set
videoTSDir = os_path_join(self.filename, 'VIDEO_TS')
if dir_exists(videoTSDir):
ifoFile = os_path_join(videoTSDir, 'VIDEO_TS.IFO')
if xbmcvfs.exists(ifoFile):
return ifoFile
# Also check for BluRay
videoBluRayDir = os_path_join(self.filename, 'BDMV')
if dir_exists(videoBluRayDir):
dbmvFile = os_path_join(videoBluRayDir, 'index.bdmv')
if xbmcvfs.exists(dbmvFile):
return dbmvFile
return None
def _getExistingCoverImage(self):
# Check if there is a cached version, or a local one on the drive
fullpathLocalImage, bookExt = os.path.splitext(self.filePath)
# Store the directory that the file is in, default the the current path
parentPath = self.filePath
# Check to see if this is actually a file with an extension
if (bookExt not in [None, ""]) and (len(bookExt) < 5):
fullpathLocalImage1 = "%s.jpg" % fullpathLocalImage
fullpathLocalImage2 = "%s.JPG" % fullpathLocalImage
if xbmcvfs.exists(fullpathLocalImage1):
log("AudioBookHandler: Found local cached image %s" % fullpathLocalImage1)
return fullpathLocalImage1
if xbmcvfs.exists(fullpathLocalImage2):
log("AudioBookHandler: Found local cached image %s" % fullpathLocalImage2)
return fullpathLocalImage2
# If we reach here, then we were a file, so get the directory part
parentPath = (os_path_split(self.filePath))[0]
# Check for a file in the same directory but with the name
# "cover.jpg" or "folder.jpg
dirs, files = xbmcvfs.listdir(parentPath)
for file in files:
if file.lower() in ['folder.jpg', 'cover.jpg']:
fullpathLocalImage = os_path_join(parentPath, file)
log("AudioBookHandler: Found local directory cover %s" % fullpathLocalImage)
return fullpathLocalImage
# Check for a cached cover
return self._getCachedCover(self.fileName)
def _getMainCoverLocation(self):
coverFileName, oldExt = os.path.splitext(self.fileName)
targetCoverName = "%s.jpg" % coverFileName
coverTargetName = os_path_join(Settings.getCoverCacheLocation(), targetCoverName)
log("AudioBookHandler: Cached cover target location is %s" % coverTargetName)
return coverTargetName
def _generateThemeFilelist(self, rawPath):
# Get the full path with any network alterations
workingPath = self._getUsablePath(rawPath)
themeList = self._getThemeFiles(workingPath)
# If no themes have been found
if len(themeList) < 1:
# TV shows stored as ripped disc folders
if ('VIDEO_TS' in workingPath) or ('BDMV' in workingPath):
log("ThemeFiles: Found VIDEO_TS or BDMV in path: Correcting the path for DVDR tv shows", self.debug_logging_enabled)
workingPath = os_path_split(workingPath)[0]
themeList = self._getThemeFiles(workingPath)
if len(themeList) < 1:
workingPath = os_path_split(workingPath)[0]
themeList = self._getThemeFiles(workingPath)
else:
# If no theme files were found in this path, look at the parent directory
workingPath = os_path_split(workingPath)[0]
# Check for the case where there is the theme forlder settings, we want to
# check the parent folders themes directory
if Settings.isThemeDirEnabled():
themeDir = os_path_join(workingPath, Settings.getThemeDirectory())
themeList = self._getThemeFiles(themeDir)
# If there are still no themes, just check the parent directory
if len(themeList) < 1:
themeList = self._getThemeFiles(workingPath)
log("ThemeFiles: Playlist size = %d" % len(themeList), self.debug_logging_enabled)
log("ThemeFiles: Working Path = %s" % workingPath, self.debug_logging_enabled)
return themeList
def getVOBFile(self):
# Check to see if the filename actually holds a directory
# If that is the case, we will only support it being a DVD Directory Image
# So check to see if the expected file is set
videoTSDir = os_path_join(self.filename, 'VIDEO_TS')
if dir_exists(videoTSDir):
ifoFile = os_path_join(videoTSDir, 'VIDEO_TS.IFO')
if xbmcvfs.exists(ifoFile):
return ifoFile
# Also check for BluRay
videoBluRayDir = os_path_join(self.filename, 'BDMV')
if dir_exists(videoBluRayDir):
dbmvFile = os_path_join(videoBluRayDir, 'index.bdmv')
if xbmcvfs.exists(dbmvFile):
return dbmvFile
return None
def __init__(self):
# Start by getting the database location
self.configPath = xbmc.translatePath(ADDON.getAddonInfo('profile'))
self.databasefile = os_path_join(self.configPath, "pinsentry_database.db")
log("PinSentryDB: Database file location = %s" % self.databasefile)
# Check to make sure the DB has been created
self._createDatabase()
def loadSavedPhrases(self):
# Get the location of the speech list file
configPath = xbmc.translatePath(ADDON.getAddonInfo('profile'))
speechfile = os_path_join(configPath, "speech.txt")
log("Speech: Phrases file location = %s" % speechfile)
phrases = []
# Check to see if the speech list file exists
if not xbmcvfs.exists(speechfile):
# Create a list of pre-defined phrases
phrases.append(ADDON.getLocalizedString(32221))
phrases.append(ADDON.getLocalizedString(32222))
phrases.append(ADDON.getLocalizedString(32226))
phrases.append('%greet')
phrases.sort()
else:
# Read the phases from the file
try:
with open(speechfile, 'r') as file_in:
phrases = file_in.readlines()
except:
log("Speech: Failed to read lines from file %s" % speechfile,
xbmc.LOGERROR)
log("Speech: %s" % traceback.format_exc(), xbmc.LOGERROR)
return phrases
def __init__(self):
# Start by getting the database location
self.configPath = xbmc.translatePath(__addon__.getAddonInfo('profile'))
self.databasefile = os_path_join(self.configPath, "audiobooks_database.db")
log("AudioBooksDB: Database file location = %s" % self.databasefile)
# Check to make sure the DB has been created
self._createDatabase()
def __init__(self, rawPath, pathList=None, videotitle=None, debug_logging_enabled=True, audioOnly=False):
self.debug_logging_enabled = debug_logging_enabled
self.forceShuffle = False
self.doNotShuffle = False
self.audioOnly = audioOnly
self.rawPath = rawPath
if rawPath in [None, ""]:
self.clear()
else:
# Check for the case where there is a custom path set so we need to use
# the custom location rather than the rawPath
if Settings.isCustomPathEnabled() and (videotitle not in [None, ""]):
customRoot = Settings.getCustomPath()
# Make sure that the path passed in has not already been converted
if customRoot not in self.rawPath:
self.rawPath = os_path_join(customRoot, normalize_string(videotitle))
log("ThemeFiles: Setting custom path to %s" % self.rawPath, self.debug_logging_enabled)
if (pathList is not None) and (len(pathList) > 0):
self.themeFiles = []
for aPath in pathList:
subThemeList = self._generateThemeFilelistWithDirs(aPath)
# add these files to the existing list
self.themeFiles = self._mergeThemeLists(self.themeFiles, subThemeList)
# If we were given a list, then we should shuffle the themes
# as we don't always want the first path playing first
self.forceShuffle = True
else:
self.themeFiles = self._generateThemeFilelistWithDirs(self.rawPath)
# Check if we need to handle the ordering for video themes
if not audioOnly:
self.doNotShuffle = self._filterForVideoThemesRule()
self.forceShuffle = False
def loadSavedPhrases(self):
# Get the location of the speech list file
configPath = xbmc.translatePath(__addon__.getAddonInfo('profile'))
speechfile = os_path_join(configPath, "speech.txt")
log("Speech: Phrases file location = %s" % speechfile)
phrases = []
# Check to see if the speech list file exists
if not xbmcvfs.exists(speechfile):
# Create a list of pre-defined phrases
phrases.append(__addon__.getLocalizedString(32221))
phrases.append(__addon__.getLocalizedString(32222))
phrases.append(__addon__.getLocalizedString(32226))
phrases.append('%greet')
phrases.sort()
else:
# Read the phases from the file
try:
file_in = open(speechfile, 'r')
phrases = file_in.readlines()
file_in.close()
except:
log("Speech: Failed to read lines from file %s" % speechfile, xbmc.LOGERROR)
log("Speech: %s" % traceback.format_exc(), xbmc.LOGERROR)
return phrases
def _getCachedCover(self, fileName):
cachedCover = None
# check if the directory exists before searching
dirs, files = xbmcvfs.listdir(Settings.getCoverCacheLocation())
for aFile in files:
# Get the filename without extension
coverSrc, ext = os.path.splitext(aFile)
# Get the name that the cached cover will have been stored as
targetSrc, bookExt = os.path.splitext(fileName)
# Make sure both are utf-8 when comparing
try:
coverSrc = coverSrc.encode("utf-8")
except:
pass
try:
targetSrc = targetSrc.encode("utf-8")
except:
pass
if targetSrc == coverSrc:
cachedCover = os_path_join(Settings.getCoverCacheLocation(), aFile)
log("AudioBookHandler: Cached cover found: %s" % cachedCover)
return cachedCover
def _getNestedExtrasFiles(self, basepath, filename, exitOnFirst=False, noExtrasDirNeeded=False):
extras = []
if dir_exists(basepath):
dirs, files = xbmcvfs.listdir(basepath)
for dirname in dirs:
# Do not search inside Bluray or DVD images
if (dirname == 'VIDEO_TS') or (dirname == 'BDMV'):
continue
dirpath = os_path_join(basepath, dirname)
log("VideoExtrasFinder: Nested check in directory: %s" % dirpath)
if dirname != Settings.getExtrasDirName():
log("VideoExtrasFinder: Check directory: %s" % dirpath)
extras.extend(self._getExtrasDirFiles(dirpath, exitOnFirst, noExtrasDirNeeded))
# Check if we are only looking for the first entry
if files and (exitOnFirst is True):
break
extras.extend(self._getExtrasFiles(dirpath, filename, exitOnFirst))
# Check if we are only looking for the first entry
if files and (exitOnFirst is True):
break
extras.extend(self._getNestedExtrasFiles(dirpath, filename, exitOnFirst, noExtrasDirNeeded))
# Check if we are only looking for the first entry
if files and (exitOnFirst is True):
break
return extras
def _getCachedCover(self, fileName):
cachedCover = None
# check if the directory exists before searching
dirs, files = xbmcvfs.listdir(Settings.getCoverCacheLocation())
for aFile in files:
# Get the filename without extension
coverSrc, ext = os.path.splitext(aFile)
# Get the name that the cached cover will have been stored as
targetSrc, bookExt = os.path.splitext(fileName)
# Make sure both are utf-8 when comparing
try:
coverSrc = coverSrc.encode("utf-8")
except:
pass
try:
targetSrc = targetSrc.encode("utf-8")
except:
pass
if targetSrc == coverSrc:
cachedCover = os_path_join(Settings.getCoverCacheLocation(), aFile)
log("AudioBookHandler: Cached cover found: %s" % cachedCover)
return cachedCover
def __init__(self):
# Start by getting the database location
self.configPath = xbmc.translatePath(ADDON.getAddonInfo('profile'))
self.databasefile = os_path_join(self.configPath, "extras_database.db")
log("ExtrasDB: Database file location = %s" % self.databasefile)
# Make sure that the database exists if this is the first time
self.createDatabase()
def __init__(self):
# Start by getting the database location
self.configPath = xbmc.translatePath(ADDON.getAddonInfo('profile'))
self.databasefile = os_path_join(self.configPath, "ebooks_database.db")
log("EbooksDB: Database file location = %s" % self.databasefile)
# Check to make sure the DB has been created
self._createDatabase()
def _addFilesFromPlaylist(self, playlistFile, directory):
if (playlistFile is None) or (playlistFile == ""):
return
fileExt = os.path.splitext(playlistFile)[1]
# Check if dealing with a Smart Playlist
if fileExt == ".xsp":
# Process the Smart Playlist
self._addFilesFromSmartPlaylist(playlistFile)
return
if ("/" not in playlistFile) and ("\\" not in playlistFile):
# There is just the filename of the playlist without
# a path, check if the file is local or if we should
# read it from the user directory
# Check if there is an extension on the name
if fileExt is None or fileExt == "":
playlistFile = playlistFile + ".m3u"
localFile = os_path_join(directory, playlistFile)
if xbmcvfs.exists(localFile):
# Make it a full path if it is not already
playlistFile = localFile
else:
# default to the music playlist directory if not local
playlistFile = os_path_join(xbmc.translatePath("special://musicplaylists"), playlistFile)
log("NfoReader: playlist file = %s" % playlistFile, self.debug_logging_enabled)
if xbmcvfs.exists(playlistFile):
# Load the playlist into the Playlist object
# An exception if thrown if the file does not exist
try:
xbmcPlaylist = xbmc.PlayList(xbmc.PLAYLIST_MUSIC)
xbmcPlaylist.load(playlistFile)
i = 0
while i < xbmcPlaylist.size():
# get the filename from the playlist
file = xbmcPlaylist[i].getfilename()
i = i + 1
if (file is not None) and (file != ""):
log("NfoReader: file from playlist = %s" % file, self.debug_logging_enabled)
self.themeFiles.append(file)
except:
log("NfoReader: playlist file processing error = %s" % playlistFile)
else:
log("NfoReader: playlist file not found = %s" % playlistFile, self.debug_logging_enabled)
def _getCustomPathDir(self, path):
# Get the last element of the path
pathLastDir = os_path_split(path)[1]
# Create the path with this added
custPath = Settings.getCustomPath(self.videoType)
custPath = os_path_join(custPath, pathLastDir)
log("VideoExtrasFinder: Checking existence of custom path %s" % custPath)
# Check if this path exists
if not dir_exists(custPath):
# If it doesn't exist, check the path before that, this covers the
# case where there is a TV Show with each season in it's own directory
# Make sure we have enough elements to actually navigate back up the path
if len(os_path_split((os_path_split(path)[0]))) < 2:
log("VideoExtrasFinder: No parent directories to check %s" % path)
else:
path2ndLastDir = os_path_split((os_path_split(path)[0]))[1]
custPath = Settings.getCustomPath(self.videoType)
custPath = os_path_join(custPath, path2ndLastDir)
custPath = os_path_join(custPath, pathLastDir)
log("VideoExtrasFinder: Checking existence of custom path %s" % custPath)
if not dir_exists(custPath):
# If it still does not exist then check just the 2nd to last path
custPath = Settings.getCustomPath(self.videoType)
custPath = os_path_join(custPath, path2ndLastDir)
log("VideoExtrasFinder: Checking existence of custom path %s" % custPath)
if not dir_exists(custPath):
# Some systems will store extras in the custom pass using the name
# of the TV Show of Movie, so try that
videoName = self.title
if self.title in [None, ""]:
if self.videoType == Settings.TVSHOWS:
videoName = xbmc.getInfoLabel("ListItem.TVShowTitle")
else:
videoName = xbmc.getInfoLabel("ListItem.Title")
videoName = normalize_string(videoName)
# Now construct the path using the movie or TV show title
custPath = Settings.getCustomPath(self.videoType)
custPath = os_path_join(custPath, videoName)
log("VideoExtrasFinder: Checking existence of custom path using title %s" % custPath)
if not dir_exists(custPath):
custPath = None
return custPath
def _getCustomPathDir(self, path):
# Get the last element of the path
pathLastDir = os_path_split(path)[1]
# Create the path with this added
custPath = Settings.getCustomPath(self.videoType)
custPath = os_path_join(custPath, pathLastDir)
log("VideoExtrasFinder: Checking existence of custom path %s" % custPath)
# Check if this path exists
if not dir_exists(custPath):
# If it doesn't exist, check the path before that, this covers the
# case where there is a TV Show with each season in it's own directory
# Make sure we have enough elements to actually navigate back up the path
if len(os_path_split((os_path_split(path)[0]))) < 2:
log("VideoExtrasFinder: No parent directories to check %s" % path)
else:
path2ndLastDir = os_path_split((os_path_split(path)[0]))[1]
custPath = Settings.getCustomPath(self.videoType)
custPath = os_path_join(custPath, path2ndLastDir)
custPath = os_path_join(custPath, pathLastDir)
log("VideoExtrasFinder: Checking existence of custom path %s" % custPath)
if not dir_exists(custPath):
# If it still does not exist then check just the 2nd to last path
custPath = Settings.getCustomPath(self.videoType)
custPath = os_path_join(custPath, path2ndLastDir)
log("VideoExtrasFinder: Checking existence of custom path %s" % custPath)
if not dir_exists(custPath):
# Some systems will store extras in the custom pass using the name
# of the TV Show of Movie, so try that
videoName = self.title
if self.title in [None, ""]:
if self.videoType == Settings.TVSHOWS:
videoName = xbmc.getInfoLabel("ListItem.TVShowTitle")
else:
videoName = xbmc.getInfoLabel("ListItem.Title")
videoName = normalize_string(videoName)
# Now construct the path using the movie or TV show title
custPath = Settings.getCustomPath(self.videoType)
custPath = os_path_join(custPath, videoName)
log("VideoExtrasFinder: Checking existence of custom path using title %s" % custPath)
if not dir_exists(custPath):
custPath = None
return custPath
def extractCoverImage(self):
log("MobiEBook: Extracting cover for %s" % self.filePath)
# Get the location that the book is to be extracted to
extractDir = os_path_join(Settings.getTempLocation(), 'mobi_extracted')
# Check if the mobi extract directory already exists
if dir_exists(extractDir):
try:
shutil.rmtree(extractDir, True)
except:
log("MobiEBook: Failed to delete directory %s" % extractDir)
# Extract the contents of the book so we can get the cover image
try:
kindleunpack.unpackBook(self.filePath, extractDir, None, '2', True)
except:
log("MobiEBook: Failed to extract cover for %s with error: %s" % (self.filePath, traceback.format_exc()), xbmc.LOGERROR)
coverTargetName = None
if dir_exists(extractDir):
coverImages = self._findCoverImage(extractDir)
if len(coverImages) > 0:
coverImageSrc = coverImages[0]
log("MobiEBook: Found cover file %s" % coverImageSrc)
coverFileName, oldExt = os.path.splitext(self.fileName)
cacheCoverName = "%s.jpg" % coverFileName
coverTargetName = os_path_join(Settings.getCoverCacheLocation(), cacheCoverName)
# Now move the file to the covers cache directory
copy = xbmcvfs.copy(coverImageSrc, coverTargetName)
if copy:
log("MobiEBook: copy successful for %s" % coverTargetName)
else:
log("MobiEBook: copy failed from %s to %s" % (coverImageSrc, coverTargetName))
else:
log("MobiEBook: No cover image found for %s" % self.filePath)
# Now tidy up the extracted data
try:
shutil.rmtree(extractDir, True)
except:
log("MobiEBook: Failed to tidy up directory %s" % extractDir)
else:
log("MobiEBook: Failed to extract Mobi file %s" % self.filePath)
return coverTargetName
def extractCoverImage(self):
log("MobiEBook: Extracting cover for %s" % self.filePath)
# Get the location that the book is to be extracted to
extractDir = os_path_join(Settings.getTempLocation(), 'mobi_extracted')
# Check if the mobi extract directory already exists
if dir_exists(extractDir):
try:
shutil.rmtree(extractDir, True)
except:
log("MobiEBook: Failed to delete directory %s" % extractDir)
# Extract the contents of the book so we can get the cover image
try:
kindleunpack.unpackBook(self.filePath, extractDir, None, '2', True)
except:
log("MobiEBook: Failed to extract cover for %s with error: %s" % (self.filePath, traceback.format_exc()), xbmc.LOGERROR)
coverTargetName = None
if dir_exists(extractDir):
coverImages = self._findCoverImage(extractDir)
if len(coverImages) > 0:
coverImageSrc = coverImages[0]
log("MobiEBook: Found cover file %s" % coverImageSrc)
coverFileName, oldExt = os.path.splitext(self.fileName)
cacheCoverName = "%s.jpg" % coverFileName
coverTargetName = os_path_join(Settings.getCoverCacheLocation(), cacheCoverName)
# Now move the file to the covers cache directory
copy = xbmcvfs.copy(coverImageSrc, coverTargetName)
if copy:
log("MobiEBook: copy successful for %s" % coverTargetName)
else:
log("MobiEBook: copy failed from %s to %s" % (coverImageSrc, coverTargetName))
else:
log("MobiEBook: No cover image found for %s" % self.filePath)
# Now tidy up the extracted data
try:
shutil.rmtree(extractDir, True)
except:
log("MobiEBook: Failed to tidy up directory %s" % extractDir)
else:
log("MobiEBook: Failed to extract Mobi file %s" % self.filePath)
return coverTargetName
def _loadSpecificDetails(self, includeCover=True):
# List all the files in the directory, as that will be the chapters
dirs, files = xbmcvfs.listdir(self.filePath)
files.sort()
# Check if the cover image is required
coverTargetName = None
if includeCover and (self.coverImage in [None, ""]):
coverTargetName = self._getMainCoverLocation()
runningStartTime = 0
for audioFile in files:
if not Settings.isPlainAudioFile(audioFile):
continue
# Store this audio file in the chapter file list
fullpath = os_path_join(self.filePath, audioFile)
self.chapterFiles.append(fullpath)
# Make the call to ffmpeg to get the details of the chapter
info = self._runFFmpegCommand(fullpath, coverTargetName)
# If we needed the cover, then save the details
if coverTargetName not in [None, ""]:
if xbmcvfs.exists(coverTargetName):
self.coverImage = coverTargetName
# Clear the cover image flag so we do not get it again
coverTargetName = None
duration = 0
chapterTitle = None
endTime = 0
if info not in [None, ""]:
if self.title in [None, ""]:
self.title = info['album']
duration = info['duration']
chapterTitle = info['title']
if duration not in [None, 0]:
endTime = runningStartTime + info['duration']
if chapterTitle in [None, ""]:
# Now generate the name of the chapter from the audio file
sections = audioFile.split('.')
sections.pop()
# Replace the dots with spaces
chapterTitle = ' '.join(sections)
detail = {
'title': chapterTitle,
'startTime': runningStartTime,
'endTime': endTime,
'duration': duration
}
self.chapters.append(detail)
# Set the next start time to be after this chapter
runningStartTime = endTime
if runningStartTime > 0:
self.totalDuration = runningStartTime
def createEBookObject(filePath):
localFilePath = filePath
removeWhenComplete = False
if filePath.startswith('smb://') or filePath.startswith('nfs://'):
try:
# Copy the file to the local disk
justFileName = os_path_split(filePath)[-1]
copiedFile = os_path_join(Settings.getTempLocation(), justFileName)
copy = xbmcvfs.copy(filePath, copiedFile)
if copy:
log("EBookBase: copy successful for %s" % copiedFile)
localFilePath = copiedFile
removeWhenComplete = True
else:
log("EBookBase: copy failed from %s to %s" % (filePath, copiedFile))
except:
log("EBookBase: Failed to copy file %s to local directory" % filePath)
elif filePath.startswith('http://') or filePath.startswith('https://'):
log("EBookBase: Book source is %s" % filePath)
try:
justFileName = 'opds.epub'
if '/mobi/' in filePath:
justFileName = 'opds.mobi'
elif '/pdf/' in filePath:
justFileName = 'opds.pdf'
copiedFile = os_path_join(Settings.getTempLocation(), justFileName)
fp, h = urllib.urlretrieve(filePath, copiedFile)
log(h)
localFilePath = copiedFile
removeWhenComplete = True
except:
log("EBookBase: Failed to download file %s to local directory" % filePath)
bookType = None
# Check which type of EBook it is
if localFilePath.lower().endswith('.epub'):
bookType = EPubEBook(localFilePath, removeWhenComplete)
elif localFilePath.lower().endswith('.mobi'):
bookType = MobiEBook(localFilePath, removeWhenComplete)
elif localFilePath.lower().endswith('.pdf'):
bookType = PdfEBook(localFilePath, removeWhenComplete)
else:
log("EBookBase: Unknown book type for %s (%s)" % (filePath, localFilePath))
return bookType
def _getAllFilesInDirectory(self, baseDir):
videoFiles = []
dirs, files = list_dir(baseDir)
# Get all the files in the current directory
for vidFile in files:
fullPath = os_path_join(baseDir, vidFile)
videoFiles.append(fullPath)
# Now check each directory
if Settings.isFolderNested():
for aDir in dirs:
fullPath = os_path_join(baseDir, aDir)
dirContents = self._getAllFilesInDirectory(fullPath)
videoFiles = videoFiles + dirContents
return videoFiles
def _getAllFilesInDirectory(self, baseDir):
videoFiles = []
dirs, files = list_dir(baseDir)
# Get all the files in the current directory
for vidFile in files:
fullPath = os_path_join(baseDir, vidFile)
videoFiles.append(fullPath)
# Now check each directory
if Settings.isFolderNested():
for aDir in dirs:
fullPath = os_path_join(baseDir, aDir)
dirContents = self._getAllFilesInDirectory(fullPath)
videoFiles = videoFiles + dirContents
return videoFiles
def createEBookObject(filePath):
localFilePath = filePath
removeWhenComplete = False
if filePath.startswith('smb://') or filePath.startswith('nfs://'):
try:
# Copy the file to the local disk
justFileName = os_path_split(filePath)[-1]
copiedFile = os_path_join(Settings.getTempLocation(), justFileName)
copy = xbmcvfs.copy(filePath, copiedFile)
if copy:
log("EBookBase: copy successful for %s" % copiedFile)
localFilePath = copiedFile
removeWhenComplete = True
else:
log("EBookBase: copy failed from %s to %s" % (filePath, copiedFile))
except:
log("EBookBase: Failed to copy file %s to local directory" % filePath)
elif filePath.startswith('http://') or filePath.startswith('https://'):
log("EBookBase: Book source is %s" % filePath)
try:
justFileName = 'opds.epub'
if '/mobi/' in filePath:
justFileName = 'opds.mobi'
elif '/pdf/' in filePath:
justFileName = 'opds.pdf'
copiedFile = os_path_join(Settings.getTempLocation(), justFileName)
fp, h = urllib.urlretrieve(filePath, copiedFile)
log(h)
localFilePath = copiedFile
removeWhenComplete = True
except:
log("EBookBase: Failed to download file %s to local directory" % filePath)
bookType = None
# Check which type of EBook it is
if localFilePath.lower().endswith('.epub'):
bookType = EPubEBook(localFilePath, removeWhenComplete)
elif localFilePath.lower().endswith('.mobi'):
bookType = MobiEBook(localFilePath, removeWhenComplete)
elif localFilePath.lower().endswith('.pdf'):
bookType = PdfEBook(localFilePath, removeWhenComplete)
else:
log("EBookBase: Unknown book type for %s (%s)" % (filePath, localFilePath))
return bookType
def _getThemeFiles(self, directory, extensionOnly=False):
# First read from the NFO file if it exists
nfoRead = NfoReader(directory, self.debug_logging_enabled)
themeFiles = nfoRead.getThemeFiles()
# Get the theme directories that are referenced and process the data in them
for nfoDir in nfoRead.getThemeDirs():
# Do not want the theme keyword if looking at an entire directory
themeFiles = themeFiles + self._getThemeFiles(nfoDir, True)
del nfoRead
themeRegex = Settings.getThemeFileRegEx(directory, extensionOnly, self.audioOnly)
log("ThemeFiles: Searching %s for %s" % (directory, themeRegex), self.debug_logging_enabled)
# Make sure that the path does not point to a plugin, as we are checking the
# file-system for themes, not plugins. This can be the case with Emby
if "plugin://" in directory:
log("ThemeFiles: Plugin paths do not support theme files: %s" % directory, self.debug_logging_enabled)
else:
# check if the directory exists before searching
if dir_exists(directory):
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(themeRegex, aFile, re.IGNORECASE)
if m:
path = os_path_join(directory, aFile)
log("ThemeFiles: Found match: %s" % path, self.debug_logging_enabled)
# Add the theme file to the list
themeFiles.append(path)
# Check to see if any themes were found, and if not see if we should try
# and use a trailer file instead
if (len(themeFiles) < 1) and (not self.audioOnly) and (not extensionOnly) and Settings.useTrailers():
trailerRegEx = Settings.getTrailerFileRegEx()
for aFile in files:
m = re.search(trailerRegEx, aFile, re.IGNORECASE)
if m:
path = os_path_join(directory, aFile)
log("ThemeFiles: Found trailer match: %s" % path, self.debug_logging_enabled)
# Add the trailer file to the list
themeFiles.append(path)
return themeFiles
def _saveAlbumArtFromMetadata(self, fullPath):
dirs, files = xbmcvfs.listdir(self.filePath)
coverImg = None
for audioFile in files:
fullPath = os_path_join(self.filePath, audioFile)
coverImg = AudioBookHandler._saveAlbumArtFromMetadata(self, fullPath)
if coverImg not in [None, ""]:
break
return coverImg
def _saveAlbumArtFromMetadata(self, fullPath):
dirs, files = xbmcvfs.listdir(self.filePath)
coverImg = None
for audioFile in files:
fullPath = os_path_join(self.filePath, audioFile)
coverImg = AudioBookHandler._saveAlbumArtFromMetadata(self, fullPath)
if coverImg not in [None, ""]:
break
return coverImg
def getPlatformLibFiles(parentDir):
if parentDir in [None, ""]:
return None
log("FFMpegLib: Looking for libraries in %s" % parentDir)
libLocation = {}
# Check if the directory exists
if dir_exists(parentDir):
# List the contents of the directory
dirs, files = xbmcvfs.listdir(parentDir)
for aFile in files:
if 'avutil' in aFile:
libLocation['avutil'] = os_path_join(parentDir, aFile)
log("FFMpegLib: Found avutil library: %s" %
libLocation['avutil'])
elif 'swresample' in aFile:
libLocation['swresample'] = os_path_join(parentDir, aFile)
log("FFMpegLib: Found swresample library: %s" %
libLocation['swresample'])
elif 'avcodec' in aFile:
libLocation['avcodec'] = os_path_join(parentDir, aFile)
log("FFMpegLib: Found avcodec library: %s" %
libLocation['avcodec'])
elif 'avformat' in aFile:
libLocation['avformat'] = os_path_join(parentDir, aFile)
log("FFMpegLib: Found avformat library: %s" %
libLocation['avformat'])
else:
log("FFMpegLib: Directory not found %s" % parentDir)
# Make sure we found all of the libraries
if len(libLocation) < 4:
return None
# Check if this is version 3 of ffmpeg as things are slightly different
if '-55' in libLocation['avutil']:
global FFMPEG_VERSION
FFMPEG_VERSION = 3
return libLocation
def _getNfoThumb(self, nfoXml):
# Get the thumbnail
thumbnail = nfoXml.findtext('thumb')
if (thumbnail is not None) and (thumbnail != ""):
# Found the thumb entry, check if this is a local path
# which just has a filename, this is the case if there are
# no forward slashes and no back slashes
if thumbnail.startswith('..') or (("/" not in thumbnail) and ("\\" not in thumbnail)):
thumbnail = os_path_join(self.directory, thumbnail)
else:
thumbnail = None
return thumbnail
def _getNfoFanart(self, nfoXml):
# Get the fanart
fanart = nfoXml.findtext('fanart')
if (fanart is not None) and (fanart != ""):
# Found the fanart entry, check if this is a local path
# which just has a filename, this is the case if there are
# no forward slashes and no back slashes
if fanart.startswith('..') or (("/" not in fanart) and ("\\" not in fanart)):
fanart = os_path_join(self.directory, fanart)
else:
fanart = None
return fanart
