def _start_download(self, entry):
        shell = self.props.shell
        self.download_url = entry.get_playback_uri()

        filemask = self.settings['filemask']
        artist = ''
        title = ''
        shell.props.db.entry_get(entry, RB.RhythmDBPropType.ARTIST, artist)
        artist = artist[:50].replace('/', '')
        shell.props.db.entry_get(entry, RB.RhythmDBPropType.TITLE, title)
        title = title[:50].replace('/', '')
        filemask = filemask.replace('%A', artist)
        filemask = filemask.replace('%T', title)

        self.filename = u"%s - %s" % (artist, title)
        self.save_location = os.path.expanduser(filemask)
        dir, file = os.path.split(self.save_location)
        if not os.path.exists(dir):
            try:
                os.makedirs(dir)
            except:
                self.error_msg = "Can't create or access directory. Check settings (Edit => Plugins => Configure)"
                self.notify_status_changed()
                return

        # Download file to the temporary folder
        self.output_file = tempfile.NamedTemporaryFile(delete=False)
        self.downloading = True
        self.notify_status_changed()

        self.downloader = RB.ChunkLoader()
        self.downloader.set_callback(self.download_callback, self.output_file)
        self.downloader.start(self.download_url, 64 * 1024)
Example #2
0
        def load_catalogue():
            def catalogue_chunk_cb(loader, chunk, total, parser):
                if chunk is None:
                    self.__load_progress.props.task_outcome = RB.TaskOutcome.COMPLETE
                    error = loader.get_error()
                    if error:
                        # report error somehow?
                        print("error loading catalogue: %s" % error)

                    try:
                        parser.close()
                    except xml.sax.SAXParseException as e:
                        # there isn't much we can do here
                        print("error parsing catalogue: %s" % e)

                    self.__show_loading_screen(False)
                    self.__catalogue_loader = None

                    # restart in-progress downloads
                    # (doesn't really belong here)
                    for f in magnatune_in_progress_dir.enumerate_children(
                            'standard::name', Gio.FileQueryInfoFlags.NONE,
                            None):
                        name = f.get_name()
                        if not name.startswith("in_progress_"):
                            continue
                        (result, uri, etag
                         ) = magnatune_in_progress_dir.resolve_relative_path(
                             name).load_contents(None)
                        uri = uri.decode('utf-8')

                        print("restarting download from %s" % uri)
                        self.__download_album(uri, name[12:])
                else:
                    # hack around some weird chars that show up in the catalogue for some reason
                    data = chunk.get_data().decode('utf-8', errors='replace')
                    data = data.replace("\x19", "'")
                    data = data.replace("\x13", "-")

                    # argh.
                    data = data.replace("Rock & Roll", "Rock & Roll")

                    try:
                        parser.feed(data)
                    except xml.sax.SAXParseException as e:
                        print("error parsing catalogue: %s" % e)

                    load_size['size'] += len(data)
                    self.__load_progress.props.task_progress = min(
                        float(load_size['size']) / total, 1.0)

            self.__has_loaded = True
            self.__load_progress = RB.TaskProgressSimple.new()
            self.__load_progress.props.task_label = _(
                "Loading Magnatune catalog")
            self.props.shell.props.task_list.add_task(self.__load_progress)

            load_size = {'size': 0}

            parser = xml.sax.make_parser()
            parser.setContentHandler(
                TrackListHandler(self.__db, self.__entry_type, self.__sku_dict,
                                 self.__home_dict, self.__art_dict))

            self.__catalogue_loader = RB.ChunkLoader()
            self.__catalogue_loader.set_callback(catalogue_chunk_cb, parser)
            self.__catalogue_loader.start(magnatune_song_info, 64 * 1024)
                self.__notify_status_changed()

            self.__has_loaded = True
            self.__updating = True
            self.__load_progress = (0, 0)  # (complete, total)
            self.__notify_status_changed()

            load_size = {'size': 0}

            parser = xml.sax.make_parser()
            parser.setContentHandler(
                TrackListHandler(self.__db, self.__entry_type, self.__sku_dict,
                                 self.__home_dict, self.__art_dict))

            self.__catalogue_loader = RB.ChunkLoader()
            self.__catalogue_loader.set_callback(catalogue_chunk_cb, parser)
            self.__catalogue_loader.start(magnatune_song_info, 64 * 1024)

        self.__catalogue_check = rb.Loader()
        self.__catalogue_check.get_url(magnatune_changed_uri, update_cb)

    def __show_loading_screen(self, show):
        if self.__info_screen is None:
            # load the builder stuff
            builder = Gtk.Builder()
            builder.add_from_file(
                rb.find_plugin_file(self.props.plugin, "magnatune-loading.ui"))
            self.__info_screen = builder.get_object(
                "magnatune_loading_scrolledwindow")
            self.pack_start(self.__info_screen, True, True, 0)