Revert ":bricks: Update to .Net 8 GA"

This reverts commit 45ce50d.

Author: russkyc

Nitefox.App/Ffmpeg/FfmpegService.cs

@@ -16,8 +16,16 @@
 using SharpCompress.Readers;
 namespace Nitefox.App.Ffmpeg;
 
-public class FfmpegService(NitefoxConfig nitefoxConfig)
+public class FfmpegService
 {
+    private readonly NitefoxConfig _nitefoxConfig;
+
+    public FfmpegService(NitefoxConfig nitefoxConfig)
+    {
+        _nitefoxConfig = nitefoxConfig;
+        
+    }
+
     public async Task<bool> StreamConvert(string url, string fileName)
     {
         return await FFMpegArguments
@@ -30,14 +38,14 @@ public void ConfigureFfmpeg()
     {
         GlobalFFOptions.Configure(new FFOptions
         {
-            BinaryFolder = nitefoxConfig.FfmpegLocation,
-            TemporaryFilesFolder = nitefoxConfig.TempFilesLocation
+            BinaryFolder = _nitefoxConfig.FfmpegLocation,
+            TemporaryFilesFolder = _nitefoxConfig.TempFilesLocation
         });
     }
 
     public async Task<bool> DownloadFfmpeg()
     {
-        if (new DirectoryInfo(nitefoxConfig.FfmpegLocation).EnumerateFiles()
+        if (new DirectoryInfo(_nitefoxConfig.FfmpegLocation).EnumerateFiles()
                 .Count() >= 3)
         {
             return true;
@@ -68,7 +76,7 @@ public async Task<bool> DownloadFfmpeg()
             releaseAsset = release.Assets.First(asset => asset.Name.EndsWith("osx-arm64.zip"));
         }
 
-        var downloadInfo = await AssetDownloader.Instance.DownloadAssetAsync(releaseAsset, nitefoxConfig.FfmpegLocation);
+        var downloadInfo = await AssetDownloader.Instance.DownloadAssetAsync(releaseAsset, _nitefoxConfig.FfmpegLocation);
 
         await Task.Run(async () =>
         {
@@ -79,7 +87,7 @@ await Task.Run(async () =>
             {
                 if (!reader.Entry.IsDirectory)
                 {
-                    reader.WriteEntryToDirectory(nitefoxConfig.FfmpegLocation, new ExtractionOptions()
+                    reader.WriteEntryToDirectory(_nitefoxConfig.FfmpegLocation, new ExtractionOptions()
                     {
                         ExtractFullPath = true,
                         Overwrite = true

Nitefox.App/Media/MediaDownloader.cs

@@ -17,16 +17,28 @@
 
 namespace Nitefox.App.Media;
 
-public class MediaDownloader(
-    IFileService fileService,
-    FfmpegService ffmpegService,
-    NitefoxConfig nitefoxConfig,
-    MetadataService metadataService)
+public class MediaDownloader
 {
-    
-    private readonly DataStore _mediaDataStore = new ($"{nitefoxConfig.DownloadLocation}downloads.json",
-        reloadBeforeGetCollection: true);
+    private readonly IFileService _fileService;
+    private readonly DataStore _mediaDataStore;
+    private readonly FfmpegService _ffmpegService;
+    private readonly NitefoxConfig _nitefoxConfig;
+    private readonly MetadataService _metadataService;
 
+    public MediaDownloader(
+        IFileService fileService,
+        FfmpegService ffmpegService,
+        NitefoxConfig nitefoxConfig,
+        MetadataService metadataService)
+    {
+        _fileService = fileService;
+        _ffmpegService = ffmpegService;
+        _nitefoxConfig = nitefoxConfig;
+        _metadataService = metadataService;
+        _mediaDataStore = new DataStore($"{_nitefoxConfig.DownloadLocation}downloads.json",
+            reloadBeforeGetCollection: true);
+    }
+    
     public async Task<TrackDownload> Download(string title, string url, string author, string? collection = null)
     {
         var trackDownload = new TrackDownload
@@ -39,12 +51,12 @@ public async Task<TrackDownload> Download(string title, string url, string autho
 
         try
         {
-            await ffmpegService.DownloadFfmpeg();
+            await _ffmpegService.DownloadFfmpeg();
 
-            ffmpegService.ConfigureFfmpeg();
-            fileService.SetupDirectories();
+            _ffmpegService.ConfigureFfmpeg();
+            _fileService.SetupDirectories();
 
-            var streamUrl = await metadataService.GetYoutubeSongStream(url);
+            var streamUrl = await _metadataService.GetYoutubeSongStream(url);
 
             if (string.IsNullOrWhiteSpace(streamUrl))
             {
@@ -53,12 +65,12 @@ public async Task<TrackDownload> Download(string title, string url, string autho
 
             if (collection is not null)
             {
-                var songAlbumPath = $"{nitefoxConfig.DownloadLocation}{collection}\\";
+                var songAlbumPath = $"{_nitefoxConfig.DownloadLocation}{collection}\\";
 
                 trackDownload.Collection = collection;
                 trackDownload.SavePath = $"{songAlbumPath}{songSaveName}";
                 trackDownload.IsDownloaded =
-                    await ffmpegService.StreamConvert(streamUrl, $"{songAlbumPath}{songSaveName}");
+                    await _ffmpegService.StreamConvert(streamUrl, $"{songAlbumPath}{songSaveName}");
 
                 if (trackDownload.IsDownloaded)
                 {
@@ -69,9 +81,9 @@ await _mediaDataStore.GetCollection<TrackDownload>()
                 return trackDownload;
             }
 
-            trackDownload.SavePath = $"{nitefoxConfig.DownloadLocation}{songSaveName}";
+            trackDownload.SavePath = $"{_nitefoxConfig.DownloadLocation}{songSaveName}";
             trackDownload.IsDownloaded =
-                await ffmpegService.StreamConvert(streamUrl, $"{nitefoxConfig.DownloadLocation}{songSaveName}");
+                await _ffmpegService.StreamConvert(streamUrl, $"{_nitefoxConfig.DownloadLocation}{songSaveName}");
 
             if (trackDownload.IsDownloaded)
             {
@@ -90,9 +102,9 @@ await _mediaDataStore.GetCollection<TrackDownload>()
 
     public async IAsyncEnumerable<TrackDownload> DownloadAlbum(string title, string id)
     {
-        fileService.CreateMediaDirectory(nitefoxConfig.DownloadLocation, title.ToPathSafeString());
+        _fileService.CreateMediaDirectory(_nitefoxConfig.DownloadLocation, title.ToPathSafeString());
 
-        foreach (var track in await metadataService.GetAlbumTracksMetadata(id, title))
+        foreach (var track in await _metadataService.GetAlbumTracksMetadata(id, title))
         {
             var authors = track.Artists.Select(artist => artist.Name).Take(3).ToDelimitedString();
             yield return await Download(track.Title, track.Url, authors, title.ToPathSafeString());
@@ -101,9 +113,9 @@ public async IAsyncEnumerable<TrackDownload> DownloadAlbum(string title, string
 
     public async IAsyncEnumerable<TrackDownload> DownloadPlaylist(string title, string id)
     {
-        fileService.CreateMediaDirectory(nitefoxConfig.DownloadLocation, title.ToPathSafeString());
+        _fileService.CreateMediaDirectory(_nitefoxConfig.DownloadLocation, title.ToPathSafeString());
 
-        foreach (var track in await metadataService.GetPlaylistTracksMetadata(id, title))
+        foreach (var track in await _metadataService.GetPlaylistTracksMetadata(id, title))
         {
             var authors = track.Artists.Select(artist => artist.Name).Take(3).ToDelimitedString();
             yield return await Download(track.Title, track.Url, authors, title.ToPathSafeString());

Nitefox.App/Media/MediaSearch.cs

@@ -14,8 +14,15 @@
 
 namespace Nitefox.App.Media;
 
-public class MediaSearch(SpotifyClient spotifyClient)
+public class MediaSearch
 {
+    private readonly SpotifyClient _spotifyClient;
+
+    public MediaSearch(SpotifyClient spotifyClient)
+    {
+        _spotifyClient = spotifyClient;
+    }
+
     public async Task<IEnumerable<ISearchResult>> SearchAsync(string query, int limit = Int32.MaxValue, int skip = 0)
     {
         try
@@ -24,15 +31,15 @@ public async Task<IEnumerable<ISearchResult>> SearchAsync(string query, int limi
 
             if (query.Contains("album", StringComparison.InvariantCultureIgnoreCase))
             {
-                return await spotifyClient.Search.GetAlbumsAsync(cleanQuery, skip, limit);
+                return await _spotifyClient.Search.GetAlbumsAsync(cleanQuery, skip, limit);
             }
 
             if (query.Contains("playlist", StringComparison.InvariantCultureIgnoreCase))
             {
-                return await spotifyClient.Search.GetPlaylistsAsync(cleanQuery, skip, limit);
+                return await _spotifyClient.Search.GetPlaylistsAsync(cleanQuery, skip, limit);
             }
 
-            return await spotifyClient.Search.GetTracksAsync(cleanQuery, skip, limit);
+            return await _spotifyClient.Search.GetTracksAsync(cleanQuery, skip, limit);
         }
         catch (Exception e)
         {

Nitefox.App/Media/MetadataService.cs

@@ -15,25 +15,34 @@
 
 namespace Nitefox.App.Media;
 
-public class MetadataService(SpotifyClient spotifyClient, YoutubeClient youtubeClient)
+public class MetadataService
 {
+    private readonly SpotifyClient _spotifyClient;
+    private readonly YoutubeClient _youtubeClient;
+
+    public MetadataService(SpotifyClient spotifyClient, YoutubeClient youtubeClient)
+    {
+        _spotifyClient = spotifyClient;
+        _youtubeClient = youtubeClient;
+    }
+
     public async Task<int> GetAlbumTrackCount(string id)
     {
-        var album = await spotifyClient.Albums.GetAsync(id);
+        var album = await _spotifyClient.Albums.GetAsync(id);
         return album.Tracks.Count;
     }
 
     public async Task<int> GetPlaylistTrackCount(string id)
     {
-        var playlists = await spotifyClient.Playlists.GetAsync(id);
+        var playlists = await _spotifyClient.Playlists.GetAsync(id);
         return playlists.Tracks.Count;
     }
 
     public async Task<string> GetAlbumImageUrl(string id)
     {
         try
         {
-            var album = await spotifyClient.Albums.GetAsync(id);
+            var album = await _spotifyClient.Albums.GetAsync(id);
             var image = album.Images.FirstOrDefault(image => !string.IsNullOrWhiteSpace(image.Url));
             if (image is null) return string.Empty;
             return image.Url;
@@ -52,7 +61,7 @@ public async Task<string> GetPlaylistImageUrl(string id)
     {
         try
         {
-            var tracks = await spotifyClient.Playlists.GetTracksAsync(id, limit: 5);
+            var tracks = await _spotifyClient.Playlists.GetTracksAsync(id, limit: 5);
             var playlistImages = tracks.SelectMany(track => track.Album.Images)
                 .Where(image => !string.IsNullOrWhiteSpace(image.Url));
             var image = playlistImages.FirstOrDefault(image => !string.IsNullOrWhiteSpace(image.Url));
@@ -71,30 +80,30 @@ public async Task<string> GetPlaylistImageUrl(string id)
 
     public async Task<string> GetYoutubeSongStream(string url)
     {
-        var youtubeId = await spotifyClient.Tracks.GetYoutubeIdAsync(url);
-        var streamManifest = await youtubeClient.Videos.Streams.GetManifestAsync($"https://youtube.com/watch?v={youtubeId}");
+        var youtubeId = await _spotifyClient.Tracks.GetYoutubeIdAsync(url);
+        var streamManifest = await _youtubeClient.Videos.Streams.GetManifestAsync($"https://youtube.com/watch?v={youtubeId}");
         return streamManifest.GetAudioOnlyStreams().GetWithHighestBitrate().Url;
     }
 
     public async Task<string> GetPreviewStream(string url)
     {
-        var youtubeId = await spotifyClient.Tracks.GetYoutubeIdAsync(url);
-        var streamManifest = await youtubeClient.Videos.Streams.GetManifestAsync($"https://youtube.com/watch?v={youtubeId}");
+        var youtubeId = await _spotifyClient.Tracks.GetYoutubeIdAsync(url);
+        var streamManifest = await _youtubeClient.Videos.Streams.GetManifestAsync($"https://youtube.com/watch?v={youtubeId}");
         return streamManifest.GetAudioOnlyStreams()
             .OrderByDescending(stream => stream.Size)
             .First().Url;
     }
 
     public async Task<IEnumerable<Track>> GetAlbumTracksMetadata(string id, string title)
     {
-        var tracks = await spotifyClient.Albums.GetAllTracksAsync(id);
+        var tracks = await _spotifyClient.Albums.GetAllTracksAsync(id);
         return tracks.AsEnumerable();
     }
 
 
     public async Task<IEnumerable<Track>> GetPlaylistTracksMetadata(string id, string title)
     {
-        var tracks = await spotifyClient.Playlists.GetAllTracksAsync(id);
+        var tracks = await _spotifyClient.Playlists.GetAllTracksAsync(id);
         return tracks.AsEnumerable();
     }
 

Nitefox.App/Nitefox.App.csproj

@@ -1,11 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <PublishAot>true</PublishAot>
-        <LangVersion>12</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
@@ -18,7 +17,6 @@
       <PackageReference Include="Russkyc.Configuration" Version="1.0.1" />
       <PackageReference Include="SharpCompress" Version="0.34.1" />
       <PackageReference Include="SpotifyExplode" Version="1.0.7" />
-      <PackageReference Include="TagLibSharp" Version="2.3.0" />
       <PackageReference Include="YoutubeExplode" Version="6.3.6" />
     </ItemGroup>
 

Nitefox.App/States/MediaPlayerState.cs

@@ -22,6 +22,7 @@ public void Play(string track, string url)
     {
         Track = track;
         StreamUrl = url;
+        Loaded = true;
     }
 
     public void Stop()

Nitefox.Client.Photino/Nitefox.Client.Photino.csproj

@@ -2,9 +2,8 @@
 
     <PropertyGroup>
         <OutputType>WinExe</OutputType>
-        <TargetFramework>net8.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
         <ApplicationIcon>nitefox_icon.ico</ApplicationIcon>
-        <LangVersion>12</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>

Nitefox.Client.Photino/Services/PhotinoFileService.cs

@@ -16,18 +16,26 @@
 
 namespace Nitefox.Client.Photino.Services;
 
-public class PhotinoFileService(NitefoxConfig nitefoxConfig) : IFileService
+public class PhotinoFileService : IFileService
 {
-    public Task<string> OpenFolder()
+    private readonly NitefoxConfig _nitefoxConfig;
+
+    public PhotinoFileService(NitefoxConfig nitefoxConfig)
+    {
+        _nitefoxConfig = nitefoxConfig;
+        SetupDirectories();
+    }
+    
+    public async Task<string> OpenFolder()
     {
         try
         {
             var path = Program.App.MainWindow.ShowOpenFolder();
-            return Task.FromResult(path[0]);
+            return path[0];
         }
         catch (Exception)
         {
-            return Task.FromResult("");
+            return "";
         }
     }
 
@@ -46,34 +54,34 @@ public bool CreateMediaDirectory(string basePath, string directoryName)
 
     public void SetupDirectories()
     {
-        if (string.IsNullOrWhiteSpace(nitefoxConfig.DownloadLocation))
+        if (string.IsNullOrWhiteSpace(_nitefoxConfig.DownloadLocation))
         {
-            nitefoxConfig.DownloadLocation = Environment.CurrentDirectory + "\\songs\\";
+            _nitefoxConfig.DownloadLocation = Environment.CurrentDirectory + "\\songs\\";
         }
 
-        if (!Directory.Exists(nitefoxConfig.DownloadLocation))
+        if (!Directory.Exists(_nitefoxConfig.DownloadLocation))
         {
-            Directory.CreateDirectory(nitefoxConfig.DownloadLocation);
+            Directory.CreateDirectory(_nitefoxConfig.DownloadLocation);
         }
 
-        if (string.IsNullOrWhiteSpace(nitefoxConfig.TempFilesLocation))
+        if (string.IsNullOrWhiteSpace(_nitefoxConfig.TempFilesLocation))
         {
-            nitefoxConfig.TempFilesLocation = Environment.CurrentDirectory + "\\temp\\";
+            _nitefoxConfig.TempFilesLocation = Environment.CurrentDirectory + "\\temp\\";
         }
 
-        if (!Directory.Exists(nitefoxConfig.TempFilesLocation))
+        if (!Directory.Exists(_nitefoxConfig.TempFilesLocation))
         {
-            Directory.CreateDirectory(nitefoxConfig.TempFilesLocation);
+            Directory.CreateDirectory(_nitefoxConfig.TempFilesLocation);
         }
 
-        if (string.IsNullOrWhiteSpace(nitefoxConfig.FfmpegLocation))
+        if (string.IsNullOrWhiteSpace(_nitefoxConfig.FfmpegLocation))
         {
-            nitefoxConfig.FfmpegLocation = Environment.CurrentDirectory + "\\ffmpeg\\";
+            _nitefoxConfig.FfmpegLocation = Environment.CurrentDirectory + "\\ffmpeg\\";
         }
 
-        if (!Directory.Exists(nitefoxConfig.FfmpegLocation))
+        if (!Directory.Exists(_nitefoxConfig.FfmpegLocation))
         {
-            Directory.CreateDirectory(nitefoxConfig.FfmpegLocation);
+            Directory.CreateDirectory(_nitefoxConfig.FfmpegLocation);
         }
     }
 }