def load_last_book():
"""
Load the last played book into the player.
"""
global __current_track
global __player
last_book = Settings.get().last_played_book
if last_book and last_book.position != 0:
query = Track.select().where(Track.id == last_book.position)
if query.exists():
last_track = query.get()
if last_track:
__player.set_state(Gst.State.NULL)
if cozy.control.filesystem_monitor.FilesystemMonitor(
).is_track_online(last_track):
path = last_track.file
else:
path = OfflineCache().get_cached_path(last_track)
if not path:
return
__player.set_property("uri", "file://" + path)
__player.set_state(Gst.State.PAUSED)
__current_track = last_track
Book.update(last_played=int(time.time())).where(
Book.id == last_book.id).execute()
emit_event("track-changed", last_track)
def load_file(track):
"""
Loads a given track into the player.
:param track: track to be loaded
"""
global __current_track
global __player
if get_gst_player_state() == Gst.State.PLAYING:
save_current_track_position()
save_current_book_position(__current_track)
__current_track = track
emit_event("stop")
__player.set_state(Gst.State.NULL)
init()
if cozy.control.filesystem_monitor.FilesystemMonitor().is_track_online(
track):
path = track.file
else:
path = OfflineCache().get_cached_path(track)
if not path:
path = track.file
__player.set_property("uri", "file://" + path)
__player.set_state(Gst.State.PAUSED)
save_current_book_position(__current_track)
Settings.update(last_played_book=__current_track.book).execute()
Book.update(last_played=int(time.time())).where(
Book.id == __current_track.book.id).execute()
emit_event("track-changed", track)
def save_current_book_position(track, pos=None):
"""
Saves the given track to it's book as the current position to the cozy.db.
:param track: track object
"""
if pos is None:
pos = track.id
Book.update(position=pos).where(Book.id == track.book.id).execute()
def __on_download_switch_changed(self, switch, state):
if self.download_switch.get_active():
Book.update(offline=True).where(Book.id == self.book.id).execute()
OfflineCache().add(self.book)
else:
Book.update(
offline=False,
downloaded=False).where(Book.id == self.book.id).execute()
OfflineCache().remove(self.book)
self._set_book_download_status(False)
def clean_books():
"""
Remove all books that have no tracks
"""
for book in Book.select():
if not get_track_for_playback(book):
Book.update(position=0).where(Book.id == book.id).execute()
if Track.select().where(Track.book == book).count() < 1:
if Settings.get().last_played_book.id == book.id:
Settings.update(last_played_book=None).execute()
book.delete_instance()
def save_current_playback_speed(book=None, speed=None):
"""
Save the current or given playback speed to the cozy.db.
:param book: Optional: Save for the given book
:param speed: Optional: Save the given speed
"""
global __speed
if book is None:
book = get_current_track().book
if speed is None:
speed = __speed
Book.update(playback_speed=speed).where(Book.id == book.id).execute()
def __on_button_press(self, eventbox, event):
"""
Play the selected track.
"""
current_track = player.get_current_track()
if current_track and current_track.id == self.track.id:
player.play_pause(None)
if player.get_gst_player_state() == Gst.State.PLAYING:
player.jump_to_ns(Track.select().where(
Track.id == self.track.id).get().position)
else:
player.load_file(
Track.select().where(Track.id == self.track.id).get())
player.play_pause(None, True)
Book.update(position=self.track).where(
Book.id == self.track.book.id).execute()
def update_book_download_status(self, book):
"""
Updates the downloaded status of a book.
"""
downloaded = True
tracks = get_tracks(book)
offline_tracks = OfflineCacheModel.select().where(
OfflineCacheModel.track in tracks)
if offline_tracks.count() < 1:
downloaded = False
else:
for track in offline_tracks:
if not track.copied:
downloaded = False
Book.update(downloaded=downloaded).where(Book.id == book.id).execute()
if downloaded:
self.emit_event("book-offline", book)
else:
self.emit_event("book-offline-removed", book)
def import_file(file, directory, path, update=False):
"""
Imports all information about a track into the database.
Note: This creates also a new album object when it doesnt exist yet.
Note: This does not check whether the file is already imported.
:return: True if file was imported, otherwise False
:return: Track object to be imported when everything passed successfully and track is not in the db already.
"""
if is_blacklisted(path):
return True, None
media_type = tools.__get_media_type(path)
track = TrackContainer(None, path)
cover = None
reader = None
track_number = None
track_data = None
# getting the some data is file specific
### MP3 ###
if "audio/mpeg" in media_type:
track_data = _get_mp3_tags(track, path)
### FLAC ###
elif "audio/flac" in media_type or "audio/x-flac" in media_type:
track_data = _get_flac_tags(track, path)
### OGG ###
elif "audio/ogg" in media_type or "audio/x-ogg" in media_type:
track_data = _get_ogg_tags(track, path)
### OPUS ###
elif "audio/opus" in media_type or "audio/x-opus" in media_type or "codecs=opus" in media_type:
track_data = _get_opus_tags(track, path)
### MP4 ###
elif "audio/mp4" in media_type or "audio/x-m4a" in media_type:
track_data = _get_mp4_tags(track, path)
### WAV ###
elif "audio/wav" in media_type or "audio/x-wav" in media_type:
track_data = TrackData(path)
track_data.length = __get_wav_track_length(path)
### File will not be imported ###
else:
# don't use _ for ignored return value -> it is reserved for gettext
ignore, file_extension = os.path.splitext(path)
log.warning("Skipping file " + path + " because of mime type " +
media_type + ".")
reporter.error(
"importer", "Mime type not detected as audio: " + media_type +
" with file ending: " + file_extension)
return False, None
track_data.modified = __get_last_modified(path)
# try to get all the remaining tags
try:
if track_data.track_number is None:
# The track number can contain the total number of tracks
track_text = str(__get_common_tag(track, "tracknumber"))
track_data.track_number = int(track_text.split("/")[0])
except Exception as e:
log.debug(e)
track_data.track_number = 0
if track_data.book_name is None:
track_data.book_name = __guess_book_name(directory)
if track_data.author is None or track_data.author == "":
if track_data.reader and len(track_data.reader) > 0:
track_data.author = track_data.reader
track_data.reader = ""
else:
track_data.author = _("Unknown Author")
if track_data.reader is None or track_data.reader == "":
track_data.reader = _("Unknown Reader")
if track_data.name is None:
track_data.name = __guess_title(file)
if not track_data.disk:
track_data.disk = 1
if not track_data.length:
# Try to get the length by using gstreamer
success, track_data.length = get_gstreamer_length(path)
if not success:
return False, None
if update:
if Book.select().where(Book.name == track_data.book_name).count() < 1:
track_data.book = Book.create(name=track_data.book_name,
author=track_data.author,
reader=track_data.reader,
position=0,
rating=-1,
cover=track_data.cover)
else:
track_data.book = Book.select().where(
Book.name == track_data.book_name).get()
Book.update(name=track_data.book_name,
author=track_data.author,
reader=track_data.reader,
cover=track_data.cover).where(
Book.id == track_data.book.id).execute()
Track.update(name=track_data.name,
number=track_data.track_number,
book=track_data.book,
disk=track_data.disk,
length=track_data.length,
modified=track_data.modified).where(
Track.file == track_data.file).execute()
else:
# create database entries
if Book.select().where(Book.name == track_data.book_name).count() < 1:
track_data.book = Book.create(name=track_data.book_name,
author=track_data.author,
reader=track_data.reader,
position=0,
rating=-1,
cover=track_data.cover)
else:
track_data.book = Book.select().where(
Book.name == track_data.book_name).get()
return True, track_data
return True, None
def __mark_as_read(self, widget, parameter):
"""
Marks a book as read.
"""
Book.update(position=-1).where(Book.id == self.book.id).execute()
