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()