internal static void QueuePodcastDownload(PodcastInfo pi)
        {
            if (pi == null || pi.DownloadInfo != null)
            {
                return;
            }

            DownloadInfo dif;

            if (pi.CanDownload)
            {
                try
                {
                    dif               = GetDownloadInfo(pi);
                    pi.DownloadInfo   = dif;
                    pi.DownloadFailed = false;
                }
                catch {
                    pi.DownloadFailed = true;
                    return;
                }

                lock (downloads.SyncRoot)
                {
                    downloads.Add(dif, pi);
                }

                DownloadCore.QueueDownload(dif);
            }
        }
        internal static void Dispose()
        {
            lock (init_sync)
            {
                if (initialized && !disposing && !disposed && !initializing)
                {
                    disposing = true;
                }
                else
                {
                    return;
                }
            }

            try
            {
                if (FeedFetcher != null)
                {
                    FeedFetcher.Cancel();
                }

                DownloadCore.DownloadCompleted   -= OnDownloadCompletedHandler;
                DownloadCore.DownloadTaskStarted -= OnDownloadTaskStartedHandler;
                DownloadCore.DownloadTaskStopped -= OnDownloadTaskStoppedHandler;

                DownloadCore.DownloadDropped    -= OnDownloadDroppedHandler;
                DownloadCore.DownloadRegistered -= OnDownloadRegisteredHandler;

                DownloadCore.RegistrationFailed -= OnRegistrationFailedHandler;

                DownloadCore.Dispose();
                Library.Dispose();

                DestroySource();
            }
            finally
            {
                lock (init_sync)
                {
                    disposing = false;
                }
            }

            lock (init_sync)
            {
                initialized = false;
                disposed    = true;
            }
        }
        internal static void QueuePodcastDownload(ICollection podcasts)
        {
            DownloadInfo tmp_dif;
            ArrayList    podcast_difs = new ArrayList();

            if (podcasts == null)
            {
                return;
            }

            lock (downloads.SyncRoot)
            {
                foreach (PodcastInfo pi in podcasts)
                {
                    if (pi == null || pi.DownloadInfo != null)
                    {
                        continue;
                    }

                    try
                    {
                        if (pi.CanDownload)
                        {
                            tmp_dif           = GetDownloadInfo(pi);
                            pi.DownloadInfo   = tmp_dif;
                            pi.DownloadFailed = false;
                            podcast_difs.Add(tmp_dif);
                            downloads.Add(tmp_dif, pi);
                        }
                    }
                    catch {
                        pi.DownloadFailed = true;
                        continue;
                    }
                }
            }

            if (podcast_difs.Count == 1)
            {
                DownloadCore.QueueDownload(podcast_difs [0] as DownloadInfo);
            }
            else if (podcast_difs.Count > 0)
            {
                DownloadCore.QueueDownload(podcast_difs);
            }
        }
        internal static void Initialize(PodcastPlugin plugin)
        {
            lock (init_sync)
            {
                if (initializing || initialized)
                {
                    return;
                }

                disposed     = false;
                initializing = true;
            }

            DownloadCore.Initialize();
            DownloadCore.MaxDownloads = 2;

            DownloadCore.DownloadCompleted   += OnDownloadCompletedHandler;
            DownloadCore.DownloadTaskStarted += OnDownloadTaskStartedHandler;
            DownloadCore.DownloadTaskStopped += OnDownloadTaskStoppedHandler;

            DownloadCore.DownloadDropped    += OnDownloadDroppedHandler;
            DownloadCore.DownloadRegistered += OnDownloadRegisteredHandler;
            DownloadCore.RegistrationFailed += OnRegistrationFailedHandler;

            downloads = new Hashtable();

            Library     = new PodcastLibrary();
            FeedFetcher = new PodcastFeedFetcher();

            Plugin = plugin;

            PodcastDBManager.InitPodcastDatabase();

            ServicePointManager.CertificatePolicy = new PodcastCertificatePolicy();

            if (Globals.Library.IsLoaded)
            {
                LoadFromDatabase();
            }
            else
            {
                Globals.Library.Reloaded += OnLibraryReloaded;
            }
        }
        internal static void CancelPodcastDownload(ICollection podcasts)
        {
            if (podcasts == null)
            {
                return;
            }

            DownloadInfo tmp         = null;
            ArrayList    cancel_list = new ArrayList();

            foreach (PodcastInfo pi in podcasts)
            {
                if (pi == null || pi.DownloadInfo == null)
                {
                    continue;
                }

                try
                {
                    if (pi.CanCancel)
                    {
                        tmp = pi.DownloadInfo;

                        if (tmp != null)
                        {
                            cancel_list.Add(tmp);
                        }
                    }
                }
                catch {
                    continue;
                }
            }

            if (cancel_list.Count == 1)
            {
                DownloadCore.Cancel(cancel_list [0] as DownloadInfo);
            }
            else if (cancel_list.Count > 1)
            {
                DownloadCore.Cancel(cancel_list);
            }
        }
Esempio n. 6
0
        static void Main(string[] args)
        {
            var url        = AskUrl();
            var path       = AskPath();
            var detph      = AskDetph();
            var extentions = new List <string> {
                "jpg", "jpeg", "png", "bmp", "css", "js"
            };
            var downloader = new DownloadCore(url, path, detph, DomainWidth.Unlimited, extentions);

            try
            {
                downloader.Process();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadLine();
        }
        internal static void CancelPodcastDownload(PodcastInfo pi)
        {
            if (pi == null || pi.DownloadInfo == null)
            {
                return;
            }

            DownloadInfo dif = pi.DownloadInfo;

            if (dif != null)
            {
                lock (downloads.SyncRoot)
                {
                    if (!downloads.Contains(dif))
                    {
                        return;
                    }

                    DownloadCore.Cancel(dif);
                }
            }
        }
 private static DownloadInfo GetDownloadInfo(PodcastInfo pi)
 {
     return(DownloadCore.CreateDownloadInfo(pi.Url.ToString(),
                                            pi.LocalDirectoryPath,
                                            pi.Length));
 }