Fix some warnings

Emby.Server.Implementations/ApplicationHost.cs

@@ -150,7 +150,7 @@ public abstract class ApplicationHost : IServerApplicationHost, IDisposable
         /// <param name="loggerFactory">Instance of the <see cref="ILoggerFactory"/> interface.</param>
         /// <param name="options">Instance of the <see cref="IStartupOptions"/> interface.</param>
         /// <param name="startupConfig">The <see cref="IConfiguration" /> interface.</param>
-        public ApplicationHost(
+        protected ApplicationHost(
             IServerApplicationPaths applicationPaths,
             ILoggerFactory loggerFactory,
             IStartupOptions options,

Emby.Server.Implementations/Channels/ChannelManager.cs

@@ -39,7 +39,7 @@ namespace Emby.Server.Implementations.Channels
     /// <summary>
     /// The LiveTV channel manager.
     /// </summary>
-    public class ChannelManager : IChannelManager
+    public class ChannelManager : IChannelManager, IDisposable
     {
         private readonly IUserManager _userManager;
         private readonly IUserDataManager _userDataManager;
@@ -52,6 +52,7 @@ public class ChannelManager : IChannelManager
         private readonly IMemoryCache _memoryCache;
         private readonly SemaphoreSlim _resourcePool = new SemaphoreSlim(1, 1);
         private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+        private bool _disposed = false;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ChannelManager"/> class.
@@ -1213,5 +1214,31 @@ internal IChannel GetChannelProvider(Guid internalChannelId)
 
             return result;
         }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and optionally managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                _resourcePool?.Dispose();
+            }
+
+            _disposed = true;
+        }
     }
 }

Emby.Server.Implementations/Channels/RefreshChannelsScheduledTask.cs

@@ -62,7 +62,7 @@ public RefreshChannelsScheduledTask(
         public string Key => "RefreshInternetChannels";
 
         /// <inheritdoc />
-        public async Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             var manager = (ChannelManager)_channelManager;
 

Emby.Server.Implementations/Data/SqliteUserDataRepository.cs

@@ -390,6 +390,7 @@ private UserItemData ReadRow(IReadOnlyList<ResultSetValue> reader)
             return userData;
         }
 
+#pragma warning disable CA2215
         /// <inheritdoc/>
         /// <remarks>
         /// There is nothing to dispose here since <see cref="BaseSqliteRepository.WriteLock"/> and
@@ -398,6 +399,10 @@ private UserItemData ReadRow(IReadOnlyList<ResultSetValue> reader)
         /// </remarks>
         protected override void Dispose(bool dispose)
         {
+            // The write lock and connection for the item repository are shared with the user data repository
+            // since they point to the same database. The item repo has responsibility for disposing these two objects,
+            // so the user data repo should not attempt to dispose them as well
         }
+#pragma warning restore CA2215
     }
 }

Emby.Server.Implementations/Images/BaseFolderImageProvider.cs

@@ -22,7 +22,7 @@ public abstract class BaseFolderImageProvider<T> : BaseDynamicImageProvider<T>
     {
         private readonly ILibraryManager _libraryManager;
 
-        public BaseFolderImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, ILibraryManager libraryManager)
+        protected BaseFolderImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, ILibraryManager libraryManager)
             : base(fileSystem, providerManager, applicationPaths, imageProcessor)
         {
             _libraryManager = libraryManager;

Emby.Server.Implementations/Library/LibraryManager.cs

@@ -1007,14 +1007,8 @@ private Guid GetItemByNameId<T>(string path)
             return GetNewItemIdInternal(path, typeof(T), forceCaseInsensitiveId);
         }
 
-        /// <summary>
-        /// Validate and refresh the People sub-set of the IBN.
-        /// The items are stored in the db but not loaded into memory until actually requested by an operation.
-        /// </summary>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <param name="progress">The progress.</param>
-        /// <returns>Task.</returns>
-        public Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
+        /// <inheritdoc />
+        public Task ValidatePeopleAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             // Ensure the location is available.
             Directory.CreateDirectory(_configurationManager.ApplicationPaths.PeoplePath);

Emby.Server.Implementations/LiveTv/EmbyTV/EncodedRecorder.cs

@@ -24,7 +24,7 @@
 
 namespace Emby.Server.Implementations.LiveTv.EmbyTV
 {
-    public class EncodedRecorder : IRecorder
+    public class EncodedRecorder : IRecorder, IDisposable
     {
         private readonly ILogger _logger;
         private readonly IMediaEncoder _mediaEncoder;
@@ -36,6 +36,7 @@ public class EncodedRecorder : IRecorder
         private Stream _logFileStream;
         private string _targetPath;
         private Process _process;
+        private bool _disposed = false;
 
         public EncodedRecorder(
             ILogger logger,
@@ -323,5 +324,35 @@ private async Task StartStreamingLog(Stream source, Stream target)
                 _logger.LogError(ex, "Error reading ffmpeg recording log");
             }
         }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and optionally managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                _logFileStream?.Dispose();
+                _process?.Dispose();
+            }
+
+            _logFileStream = null;
+            _process = null;
+
+            _disposed = true;
+        }
     }
 }

Emby.Server.Implementations/LiveTv/Listings/SchedulesDirect.cs

@@ -28,7 +28,7 @@
 
 namespace Emby.Server.Implementations.LiveTv.Listings
 {
-    public class SchedulesDirect : IListingsProvider
+    public class SchedulesDirect : IListingsProvider, IDisposable
     {
         private const string ApiUrl = "https://json.schedulesdirect.org/20141201";
 
@@ -39,6 +39,7 @@ public class SchedulesDirect : IListingsProvider
         private readonly ConcurrentDictionary<string, NameValuePair> _tokens = new ConcurrentDictionary<string, NameValuePair>();
         private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
         private DateTime _lastErrorResponse;
+        private bool _disposed = false;
 
         public SchedulesDirect(
             ILogger<SchedulesDirect> logger,
@@ -58,8 +59,8 @@ private static List<string> GetScheduleRequestDates(DateTime startDateUtc, DateT
         {
             var dates = new List<string>();
 
-            var start = new List<DateTime> { startDateUtc, startDateUtc.ToLocalTime() }.Min().Date;
-            var end = new List<DateTime> { endDateUtc, endDateUtc.ToLocalTime() }.Max().Date;
+            var start = new[] { startDateUtc, startDateUtc.ToLocalTime() }.Min().Date;
+            var end = new[] { endDateUtc, endDateUtc.ToLocalTime() }.Max().Date;
 
             while (start <= end)
             {
@@ -822,5 +823,31 @@ public async Task<List<ChannelInfo>> GetChannels(ListingsProviderInfo info, Canc
 
             return list;
         }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and optionally managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                _tokenSemaphore?.Dispose();
+            }
+
+            _disposed = true;
+        }
     }
 }

Emby.Server.Implementations/LiveTv/RefreshGuideScheduledTask.cs

@@ -50,7 +50,7 @@ public RefreshGuideScheduledTask(ILiveTvManager liveTvManager, IConfigurationMan
         public string Key => "RefreshGuide";
 
         /// <inheritdoc />
-        public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             var manager = (LiveTvManager)_liveTvManager;
 

Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs

@@ -414,7 +414,7 @@ private async Task ExecuteInternal(TaskOptions options)
                     CurrentCancellationTokenSource.CancelAfter(TimeSpan.FromTicks(options.MaxRuntimeTicks.Value));
                 }
 
-                await ScheduledTask.Execute(CurrentCancellationTokenSource.Token, progress).ConfigureAwait(false);
+                await ScheduledTask.ExecuteAsync(progress, CurrentCancellationTokenSource.Token).ConfigureAwait(false);
 
                 status = TaskCompletionStatus.Completed;
             }
@@ -757,6 +757,10 @@ private void DisposeTriggers()
                 var trigger = triggerInfo.Item2;
                 trigger.Triggered -= OnTriggerTriggered;
                 trigger.Stop();
+                if (trigger is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
             }
         }
     }

Emby.Server.Implementations/ScheduledTasks/Tasks/ChapterImagesTask.cs

@@ -88,13 +88,8 @@ public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
             };
         }
 
-        /// <summary>
-        /// Returns the task to be executed.
-        /// </summary>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <param name="progress">The progress.</param>
-        /// <returns>Task.</returns>
-        public async Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        /// <inheritdoc />
+        public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             var videos = _libraryManager.GetItemList(new InternalItemsQuery
             {

Emby.Server.Implementations/ScheduledTasks/Tasks/CleanActivityLogTask.cs

@@ -57,12 +57,12 @@ public CleanActivityLogTask(
         public bool IsLogged => true;
 
         /// <inheritdoc />
-        public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             var retentionDays = _serverConfigurationManager.Configuration.ActivityLogRetentionDays;
             if (!retentionDays.HasValue || retentionDays < 0)
             {
-                throw new Exception($"Activity Log Retention days must be at least 0. Currently: {retentionDays}");
+                throw new InvalidOperationException($"Activity Log Retention days must be at least 0. Currently: {retentionDays}");
             }
 
             var startDate = DateTime.UtcNow.AddDays(-retentionDays.Value);

Emby.Server.Implementations/ScheduledTasks/Tasks/DeleteCacheFileTask.cs

@@ -79,19 +79,14 @@ public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
             };
         }
 
-        /// <summary>
-        /// Returns the task to be executed.
-        /// </summary>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <param name="progress">The progress.</param>
-        /// <returns>Task.</returns>
-        public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        /// <inheritdoc />
+        public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             var minDateModified = DateTime.UtcNow.AddDays(-30);
 
             try
             {
-                DeleteCacheFilesFromDirectory(cancellationToken, _applicationPaths.CachePath, minDateModified, progress);
+                DeleteCacheFilesFromDirectory(_applicationPaths.CachePath, minDateModified, progress, cancellationToken);
             }
             catch (DirectoryNotFoundException)
             {
@@ -104,7 +99,7 @@ public Task Execute(CancellationToken cancellationToken, IProgress<double> progr
 
             try
             {
-                DeleteCacheFilesFromDirectory(cancellationToken, _applicationPaths.TempDirectory, minDateModified, progress);
+                DeleteCacheFilesFromDirectory(_applicationPaths.TempDirectory, minDateModified, progress, cancellationToken);
             }
             catch (DirectoryNotFoundException)
             {
@@ -117,11 +112,11 @@ public Task Execute(CancellationToken cancellationToken, IProgress<double> progr
         /// <summary>
         /// Deletes the cache files from directory with a last write time less than a given date.
         /// </summary>
-        /// <param name="cancellationToken">The task cancellation token.</param>
         /// <param name="directory">The directory.</param>
         /// <param name="minDateModified">The min date modified.</param>
         /// <param name="progress">The progress.</param>
-        private void DeleteCacheFilesFromDirectory(CancellationToken cancellationToken, string directory, DateTime minDateModified, IProgress<double> progress)
+        /// <param name="cancellationToken">The task cancellation token.</param>
+        private void DeleteCacheFilesFromDirectory(string directory, DateTime minDateModified, IProgress<double> progress, CancellationToken cancellationToken)
         {
             var filesToDelete = _fileSystem.GetFiles(directory, true)
                 .Where(f => _fileSystem.GetLastWriteTimeUtc(f) < minDateModified)

Emby.Server.Implementations/ScheduledTasks/Tasks/DeleteLogFileTask.cs

@@ -69,13 +69,8 @@ public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
             };
         }
 
-        /// <summary>
-        /// Returns the task to be executed.
-        /// </summary>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <param name="progress">The progress.</param>
-        /// <returns>Task.</returns>
-        public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        /// <inheritdoc />
+        public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             // Delete log files more than n days old
             var minDateModified = DateTime.UtcNow.AddDays(-_configurationManager.CommonConfiguration.LogFileRetentionDays);

Emby.Server.Implementations/ScheduledTasks/Tasks/DeleteTranscodeFileTask.cs

@@ -78,30 +78,25 @@ public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
             };
         }
 
-        /// <summary>
-        /// Returns the task to be executed.
-        /// </summary>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <param name="progress">The progress.</param>
-        /// <returns>Task.</returns>
-        public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        /// <inheritdoc />
+        public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             var minDateModified = DateTime.UtcNow.AddDays(-1);
             progress.Report(50);
 
-            DeleteTempFilesFromDirectory(cancellationToken, _configurationManager.GetTranscodePath(), minDateModified, progress);
+            DeleteTempFilesFromDirectory(_configurationManager.GetTranscodePath(), minDateModified, progress, cancellationToken);
 
             return Task.CompletedTask;
         }
 
         /// <summary>
         /// Deletes the transcoded temp files from directory with a last write time less than a given date.
         /// </summary>
-        /// <param name="cancellationToken">The task cancellation token.</param>
         /// <param name="directory">The directory.</param>
         /// <param name="minDateModified">The min date modified.</param>
         /// <param name="progress">The progress.</param>
-        private void DeleteTempFilesFromDirectory(CancellationToken cancellationToken, string directory, DateTime minDateModified, IProgress<double> progress)
+        /// <param name="cancellationToken">The task cancellation token.</param>
+        private void DeleteTempFilesFromDirectory(string directory, DateTime minDateModified, IProgress<double> progress, CancellationToken cancellationToken)
         {
             var filesToDelete = _fileSystem.GetFiles(directory, true)
                 .Where(f => _fileSystem.GetLastWriteTimeUtc(f) < minDateModified)

Emby.Server.Implementations/ScheduledTasks/Tasks/OptimizeDatabaseTask.cs

@@ -69,13 +69,8 @@ public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
             };
         }
 
-        /// <summary>
-        /// Returns the task to be executed.
-        /// </summary>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <param name="progress">The progress.</param>
-        /// <returns>Task.</returns>
-        public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        /// <inheritdoc />
+        public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
             _logger.LogInformation("Optimizing and vacuuming jellyfin.db...");