Combine Streamable and Processable, remove unused events.

Source/FileLiberator/ConvertToMp3.cs

@@ -20,11 +20,9 @@ namespace FileLiberator
         private long fileSize;
         private static string Mp3FileName(string m4bPath) => Path.ChangeExtension(m4bPath ?? "", ".mp3");
 
-        private bool cancelled = false;
         public override void Cancel()
         {            
             m4bBook?.Cancel();
-            cancelled = true;
         }
 
         public static bool ValidateMp3(LibraryBook libraryBook)
@@ -39,8 +37,6 @@ namespace FileLiberator
         {
             OnBegin(libraryBook);
 
-            OnStreamingBegin($"Begin converting {libraryBook} to mp3");
-
             try
             {
                 var m4bPath = AudibleFileStorage.Audio.GetPath(libraryBook.Book.AudibleProductId);
@@ -73,7 +69,6 @@ namespace FileLiberator
             }
             finally
             {
-                OnStreamingCompleted($"Completed converting to mp3: {libraryBook.Book.Title}");
                 OnCompleted(libraryBook);
             }
         }

Source/FileLiberator/DownloadDecryptBook.cs

@@ -95,54 +95,45 @@ namespace FileLiberator
 
         private async Task<bool> downloadAudiobookAsync(LibraryBook libraryBook)
         {
-            OnStreamingBegin($"Begin decrypting {libraryBook}");
+            var config = Configuration.Instance;
 
-            try
+            downloadValidation(libraryBook);
+
+            var api = await libraryBook.GetApiAsync();
+            var contentLic = await api.GetDownloadLicenseAsync(libraryBook.Book.AudibleProductId);
+            var audiobookDlLic = BuildDownloadOptions(config, contentLic);
+
+            var outFileName = AudibleFileStorage.Audio.GetInProgressFilename(libraryBook, audiobookDlLic.OutputFormat.ToString().ToLower());
+            var cacheDir = AudibleFileStorage.DownloadsInProgressDirectory;
+
+            if (contentLic.DrmType != AudibleApi.Common.DrmType.Adrm)
+                abDownloader = new UnencryptedAudiobookDownloader(outFileName, cacheDir, audiobookDlLic);
+            else
             {
-                var config = Configuration.Instance;
+                AaxcDownloadConvertBase converter
+                    = config.SplitFilesByChapter ? new AaxcDownloadMultiConverter(
+                        outFileName, cacheDir, audiobookDlLic,
+                        AudibleFileStorage.Audio.CreateMultipartRenamerFunc(libraryBook))
+                    : new AaxcDownloadSingleConverter(outFileName, cacheDir, audiobookDlLic);
 
-                downloadValidation(libraryBook);
+                if (config.AllowLibationFixup)
+                    converter.RetrievedMetadata += (_, tags) => tags.Generes = string.Join(", ", libraryBook.Book.CategoriesNames());
 
-                var api = await libraryBook.GetApiAsync();
+                abDownloader = converter;
-                var contentLic = await api.GetDownloadLicenseAsync(libraryBook.Book.AudibleProductId);
-                var audiobookDlLic = BuildDownloadOptions(config, contentLic);
-
-                var outFileName = AudibleFileStorage.Audio.GetInProgressFilename(libraryBook, audiobookDlLic.OutputFormat.ToString().ToLower());
-                var cacheDir = AudibleFileStorage.DownloadsInProgressDirectory;
-
-                if (contentLic.DrmType != AudibleApi.Common.DrmType.Adrm)
-                    abDownloader = new UnencryptedAudiobookDownloader(outFileName, cacheDir, audiobookDlLic);
-                else
-                {
-                    AaxcDownloadConvertBase converter
-                        = config.SplitFilesByChapter ? new AaxcDownloadMultiConverter(
-                            outFileName, cacheDir, audiobookDlLic,
-                            AudibleFileStorage.Audio.CreateMultipartRenamerFunc(libraryBook))
-                        : new AaxcDownloadSingleConverter(outFileName, cacheDir, audiobookDlLic);
-
-                    if (config.AllowLibationFixup)
-                        converter.RetrievedMetadata += (_, tags) => tags.Generes = string.Join(", ", libraryBook.Book.CategoriesNames());
-
-                    abDownloader = converter;
-                }
-
-                abDownloader.DecryptProgressUpdate += OnStreamingProgressChanged;
-                abDownloader.DecryptTimeRemaining += OnStreamingTimeRemaining;
-                abDownloader.RetrievedTitle += OnTitleDiscovered;
-                abDownloader.RetrievedAuthors += OnAuthorsDiscovered;
-                abDownloader.RetrievedNarrators += OnNarratorsDiscovered;
-                abDownloader.RetrievedCoverArt += AaxcDownloader_RetrievedCoverArt;
-                abDownloader.FileCreated += (_, path) => OnFileCreated(libraryBook, path);
-
-                // REAL WORK DONE HERE
-                var success = await Task.Run(abDownloader.Run);
-
-                return success;
-            }
-            finally
-            {
-                OnStreamingCompleted($"Completed downloading and decrypting {libraryBook.Book.Title}");
             }
+
+            abDownloader.DecryptProgressUpdate += OnStreamingProgressChanged;
+            abDownloader.DecryptTimeRemaining += OnStreamingTimeRemaining;
+            abDownloader.RetrievedTitle += OnTitleDiscovered;
+            abDownloader.RetrievedAuthors += OnAuthorsDiscovered;
+            abDownloader.RetrievedNarrators += OnNarratorsDiscovered;
+            abDownloader.RetrievedCoverArt += AaxcDownloader_RetrievedCoverArt;
+            abDownloader.FileCreated += (_, path) => OnFileCreated(libraryBook, path);
+
+            // REAL WORK DONE HERE
+            var success = await Task.Run(abDownloader.Run);
+
+            return success;
         }
 
         private static DownloadOptions BuildDownloadOptions(Configuration config, AudibleApi.Common.ContentLicense contentLic)
@@ -175,7 +166,6 @@ namespace FileLiberator
 
             if (config.AllowLibationFixup || outputFormat == OutputFormat.Mp3)
             {
-
                 long startMs = audiobookDlLic.TrimOutputToChapterLength ?
                     contentLic.ContentMetadata.ChapterInfo.BrandIntroDurationMs : 0;
 

Source/FileLiberator/DownloadPdf.cs

@@ -57,27 +57,18 @@ namespace FileLiberator
 
 		private async Task<string> downloadPdfAsync(LibraryBook libraryBook, string proposedDownloadFilePath)
 		{
-			OnStreamingBegin(proposedDownloadFilePath);
+			var api = await libraryBook.GetApiAsync();
+			var downloadUrl = await api.GetPdfDownloadLinkAsync(libraryBook.Book.AudibleProductId);
 
-			try
+			var progress = new Progress<DownloadProgress>(OnStreamingProgressChanged);
-			{
-				var api = await libraryBook.GetApiAsync();
-				var downloadUrl = await api.GetPdfDownloadLinkAsync(libraryBook.Book.AudibleProductId);
 
-				var progress = new Progress<DownloadProgress>(OnStreamingProgressChanged);
+			var client = new HttpClient();
 
-				var client = new HttpClient();
+			var actualDownloadedFilePath = await client.DownloadFileAsync(downloadUrl, proposedDownloadFilePath, progress);
+			OnFileCreated(libraryBook, actualDownloadedFilePath);
 
-				var actualDownloadedFilePath = await client.DownloadFileAsync(downloadUrl, proposedDownloadFilePath, progress);
+			OnStatusUpdate(actualDownloadedFilePath);
-				OnFileCreated(libraryBook, actualDownloadedFilePath);
+			return actualDownloadedFilePath;
-
-				OnStatusUpdate(actualDownloadedFilePath);
-				return actualDownloadedFilePath;
-			}
-			finally
-			{
-				OnStreamingCompleted(proposedDownloadFilePath);
-			}
 		}
 
 		private static StatusHandler verifyDownload(string actualDownloadedFilePath)

Source/FileLiberator/Processable.cs

@@ -5,17 +5,22 @@ using System.Threading.Tasks;
 using DataLayer;
 using Dinah.Core;
 using Dinah.Core.ErrorHandling;
+using Dinah.Core.Net.Http;
 using LibationFileManager;
 
 namespace FileLiberator
 {
-    public abstract class Processable : Streamable
+    public abstract class Processable
     {
         public abstract string Name { get; }
         public event EventHandler<LibraryBook> Begin;
 
         /// <summary>General string message to display. DON'T rely on this for success, failure, or control logic</summary>
         public event EventHandler<string> StatusUpdate;
+        /// <summary>Fired when a file is successfully saved to disk</summary>
+        public event EventHandler<(string id, string path)> FileCreated;
+        public event EventHandler<DownloadProgress> StreamingProgressChanged;
+        public event EventHandler<TimeSpan> StreamingTimeRemaining;
 
         public event EventHandler<LibraryBook> Completed;
 
@@ -69,6 +74,23 @@ namespace FileLiberator
             StatusUpdate?.Invoke(this, statusUpdate);
         }
 
+        protected void OnFileCreated(LibraryBook libraryBook, string path)
+        {
+            Serilog.Log.Logger.Information("File created {@DebugInfo}", new { Name = nameof(FileCreated), libraryBook.Book.AudibleProductId, path });
+            FilePathCache.Insert(libraryBook.Book.AudibleProductId, path);
+            FileCreated?.Invoke(this, (libraryBook.Book.AudibleProductId, path));
+        }
+
+        protected void OnStreamingProgressChanged(DownloadProgress progress)
+            => OnStreamingProgressChanged(null, progress);
+        protected void OnStreamingProgressChanged(object _, DownloadProgress progress)
+            => StreamingProgressChanged?.Invoke(this, progress);
+
+        protected void OnStreamingTimeRemaining(TimeSpan timeRemaining)
+            => OnStreamingTimeRemaining(null, timeRemaining);
+        protected void OnStreamingTimeRemaining(object _, TimeSpan timeRemaining)
+            => StreamingTimeRemaining?.Invoke(this, timeRemaining);
+
         protected void OnCompleted(LibraryBook libraryBook)
         {
             Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(Completed), Book = libraryBook.LogFriendly() });

Source/FileLiberator/Streamable.cs

@@ -1,47 +0,0 @@
-using System;
-using Dinah.Core.Net.Http;
-
-namespace FileLiberator
-{
-    public abstract class Streamable
-    {
-        public event EventHandler<string> StreamingBegin;
-        public event EventHandler<DownloadProgress> StreamingProgressChanged;
-        public event EventHandler<TimeSpan> StreamingTimeRemaining;
-        public event EventHandler<string> StreamingCompleted;
-        /// <summary>Fired when a file is successfully saved to disk</summary>
-        public event EventHandler<(string id, string path)> FileCreated;
-
-        protected void OnStreamingBegin(string filePath)
-        {
-            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(StreamingBegin), Message = filePath });
-            StreamingBegin?.Invoke(this, filePath);
-        }
-
-        protected void OnStreamingProgressChanged(DownloadProgress progress) => OnStreamingProgressChanged(null, progress);
-        protected void OnStreamingProgressChanged(object _, DownloadProgress progress)
-        {
-            StreamingProgressChanged?.Invoke(this, progress);
-        }
-
-        protected void OnStreamingTimeRemaining(TimeSpan timeRemaining) => OnStreamingTimeRemaining(null, timeRemaining);
-        protected void OnStreamingTimeRemaining(object _, TimeSpan timeRemaining)
-        {
-            StreamingTimeRemaining?.Invoke(this, timeRemaining);
-        }
-
-        protected void OnStreamingCompleted(string filePath)
-        {
-            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(StreamingCompleted), Message = filePath });
-            StreamingCompleted?.Invoke(this, filePath);
-        }
-
-        protected void OnFileCreated(DataLayer.LibraryBook libraryBook, string path) => OnFileCreated(libraryBook.Book.AudibleProductId, path);
-        protected void OnFileCreated(string id, string path)
-        {
-            Serilog.Log.Logger.Information("File created {@DebugInfo}", new { Name = nameof(FileCreated), id, path });
-            LibationFileManager.FilePathCache.Insert(id, path);
-            FileCreated?.Invoke(this, (id, path));
-        }
-    }
-}