void OnDoapDownloaderFinished (HttpDownloader obj)
{
if (obj.State.FailureException != null) {
if (verbose) {
DisplayMessage (Catalog.GetString ("Can't check for updates"),
Catalog.GetString ("We're currently not able to check if there's a new version available. Please try again later."), MessageType.Error);
}
} else {
var doap = XDocument.Load (temp_doap_path);
var ns_doap = XNamespace.Get ("http://usefulinc.com/ns/doap#");
unstable_version = doap.Descendants (ns_doap + "Version")
.Where (p => p.Element (ns_doap + "branch").Value.StartsWith ("master"))
.Select (p => new { Revision = p.Element (ns_doap + "revision").Value })
.First ()
.Revision;
// once we have the version information, the temporary local copy of doap may be deleted
File.Delete (temp_doap_path);
if (!String.IsNullOrEmpty (unstable_version) &&
Banshee.ServiceStack.Application.Version != "Unknown" &&
new Version (Banshee.ServiceStack.Application.Version) < new Version (unstable_version)) {
Gtk.Application.Invoke (delegate {
DisplayUpdateAvailableDialog ();
});
} else {
if (verbose) {
DisplayMessage (Catalog.GetString ("No update available"), Catalog.GetString ("You already have the latest version of Banshee installed."), MessageType.Info);
}
}
}
}
public void QueueDownloader (HttpDownloader downloader)
{
lock (SyncRoot) {
pending_downloaders.Enqueue (downloader);
Update ();
}
}
void OnDownloaderFinished(HttpDownloader downloader)
{
lock (manager.SyncRoot) {
finished_count++;
if (manager.TotalDownloadCount <= 0)
{
OnFinished();
}
}
}
protected virtual void OnDownloaderFinished(HttpDownloader downloader)
{
lock (SyncRoot) {
active_downloaders.Remove(downloader);
Update();
}
var handler = Finished;
if (handler != null)
{
handler(downloader);
}
}
private void OnDownloaderProgress(HttpDownloader downloader)
{
FreezeUpdate();
lock (manager.SyncRoot) {
double weight = 1.0 / (manager.TotalDownloadCount + finished_count);
double progress = finished_count * weight;
double speed = 0;
int count = 0;
foreach (var active_downloader in manager.ActiveDownloaders)
{
progress += weight * active_downloader.State.PercentComplete;
speed = active_downloader.State.TransferRate;
count++;
}
Progress = progress;
var human_speed = new Hyena.Query.FileSizeQueryValue((long)Math.Round(speed)).ToUserQuery();
if (manager.PendingDownloadCount == 0)
{
Status = String.Format(
Catalog.GetPluralString(
"{0} download at {1}/s",
"{0} downloads at {1}/s",
count),
count, human_speed
);
}
else
{
Status = String.Format(
Catalog.GetPluralString(
"{0} download at {1}/s ({2} pending)",
"{0} downloads at {1}/s ({2} pending)",
count),
count, human_speed, manager.PendingDownloadCount
);
}
}
ThawUpdate(true);
}
private void OnDownloaderProgress (HttpDownloader downloader)
{
FreezeUpdate ();
lock (manager.SyncRoot) {
double weight = 1.0 / (manager.TotalDownloadCount + finished_count);
double progress = finished_count * weight;
double speed = 0;
int count = 0;
foreach (var active_downloader in manager.ActiveDownloaders) {
progress += weight * active_downloader.State.PercentComplete;
speed = active_downloader.State.TransferRate;
count++;
}
Progress = progress;
var human_speed = new Hyena.Query.FileSizeQueryValue ((long)Math.Round (speed)).ToUserQuery ();
if (manager.PendingDownloadCount == 0) {
Status = String.Format (
Catalog.GetPluralString (
"{0} download at {1}/s",
"{0} downloads at {1}/s",
count),
count, human_speed
);
} else {
Status = String.Format (
Catalog.GetPluralString (
"{0} download at {1}/s ({2} pending)",
"{0} downloads at {1}/s ({2} pending)",
count),
count, human_speed, manager.PendingDownloadCount
);
}
}
ThawUpdate (true);
}
protected virtual void OnDownloaderBufferUpdated (HttpDownloader downloader)
{
var handler = BufferUpdated;
if (handler != null) {
handler (downloader);
}
}
protected virtual void OnDownloaderProgress (HttpDownloader downloader)
{
var handler = Progress;
if (handler != null) {
handler (downloader);
}
}
protected virtual void OnDownloaderProgress(HttpDownloader downloader)
{
Progress?.Invoke(downloader);
}
protected virtual void OnDownloaderStarted (HttpDownloader downloader)
{
var handler = Started;
if (handler != null) {
handler (downloader);
}
}
private void OnDownloaderFinished (HttpDownloader downloader)
{
lock (manager.SyncRoot) {
finished_count++;
if (manager.TotalDownloadCount <= 0) {
OnFinished ();
}
}
}
void OnInstallerDownloaderFinished (HttpDownloader obj)
{
base.OnDownloaderFinished (obj);
if (obj.State.FailureException != null) {
DisplayMessage (Catalog.GetString ("Update download failed"), Catalog.GetString ("The download failed. Please try again later."), MessageType.Error);
} else {
Gtk.Application.Invoke (delegate {
DisplayUpdateFinishedDownloadingDialog ();
});
}
}
void OnInstallerDownloaderProgress (HttpDownloader obj)
{
string downloaded = Math.Round (obj.State.TotalBytesRead / 1024d / 1024d, 1).ToString ("F1");
string total = Math.Round (obj.State.TotalBytesExpected / 1024d / 1024d, 1).ToString ();
string rate = Math.Round (obj.State.TransferRate / 1024d, 1).ToString ("F1");
job.Progress = obj.State.PercentComplete;
job.Status = String.Format ("{0} MB / {1} MB ({2} KB/s)", downloaded, total, rate);
}
protected virtual void OnDownloaderBufferUpdated(HttpDownloader downloader)
{
BufferUpdated?.Invoke(downloader);
}
protected override void OnDownloaderStarted (HttpDownloader downloader)
{
base.OnDownloaderStarted (downloader);
Log.InformationFormat ("Starting to download {0}", downloader.Name);
}
protected virtual void OnDownloaderFinished (HttpDownloader downloader)
{
lock (SyncRoot) {
active_downloaders.Remove (downloader);
Update ();
}
var handler = Finished;
if (handler != null) {
handler (downloader);
}
}
protected override void OnDownloaderFinished (HttpDownloader downloader)
{
var file_downloader = (HttpFileDownloader)downloader;
if (job.IsCancelRequested) {
Log.InformationFormat ("Cancelled download {0}", file_downloader.LocalPath);
File.Delete (file_downloader.LocalPath);
base.OnDownloaderFinished (downloader);
return;
}
Log.InformationFormat ("Finished downloading {0}", file_downloader.LocalPath);
job.Status = AddinManager.CurrentLocalizer.GetString ("Importing...");
job.Progress = 0.0;
if (mimetype == "application/zip") {
string unzip_dir = String.Concat (file_downloader.LocalPath, Path.GetRandomFileName ());
Directory.CreateDirectory (unzip_dir);
using (ZipInputStream s = new ZipInputStream (File.OpenRead (file_downloader.LocalPath))) {
ZipEntry zip_entry;
while ((zip_entry = s.GetNextEntry ()) != null) {
string filename = Path.GetFileName (zip_entry.Name);
string extracted_file = Paths.Combine (unzip_dir, filename);
if (filename != String.Empty) {
using (FileStream streamWriter = File.Create (extracted_file)) {
int size = 2048;
byte[] data = new byte[size];
while (true) {
size = s.Read (data, 0, data.Length);
if (size > 0) {
streamWriter.Write (data, 0, size);
} else {
break;
}
}
}
Log.DebugFormat ("Unzipped {0}", extracted_file);
import_manager.Enqueue (extracted_file);
}
}
}
Directory.Delete (unzip_dir, true);
} else {
if (import_manager.ImportTrack (file_downloader.LocalPath) != null) {
import_manager.NotifyAllSources ();
}
}
File.Delete (file_downloader.LocalPath);
base.OnDownloaderFinished (downloader);
}
protected virtual void OnDownloaderStarted(HttpDownloader downloader)
{
Started?.Invoke(downloader);
}
