Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions Assets/NavViewMenu/AppData.json
Original file line number Diff line number Diff line change
Expand Up @@ -55,6 +55,12 @@
"Title": "Years",
"IconGlyph": "E787",
"HideItem": false
},
{
"UniqueId": "Tunetastic.Views.LibraryViews.FoldersViewPage",
"Title": "Folders",
"IconGlyph": "E838",
"HideItem": false
}
]
},
Expand Down
7 changes: 7 additions & 0 deletions Common/Enums.cs
Original file line number Diff line number Diff line change
Expand Up @@ -275,6 +275,13 @@ public enum LocalSave
ArtistDetailViewSortOrder,
ArtistDetailViewStyle,
SelectedArtist,
FoldersEnabled,
FoldersViewMode,
FoldersViewSortOrder,
FolderDetailViewSortBy,
FolderDetailViewSortOrder,
FolderDetailViewStyle,
SelectedFolder,
CheckForUpdatesAtStatup,
ShowVersionInfoOnTitleBar,
ForwardRewindButtonVisibility,
Expand Down
22 changes: 22 additions & 0 deletions Common/Models.cs
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,12 @@ public class Song
public string? FileSize { get; set; }
public string PlayerType { get; set; } = "Flyleaf";
public int? Track { get; set; }

[Ignore]
public bool IsFolder { get; set; }

[Ignore]
public int FolderSongCount { get; set; }
}

/// <summary>
Expand Down Expand Up @@ -227,6 +233,22 @@ public class ArtistModel
public double TotalDuration { get; set; }
}

/// <summary>
/// Represents a folder entity containing music tracks.
/// Used in FoldersViewPage for flat and hierarchical views.
/// </summary>
public class FolderModel
{
public string Name { get; set; } = string.Empty;
public string Path { get; set; } = string.Empty;
public int Count { get; set; }
public int TotalSongCount { get; set; }
public int SubFolderCount { get; set; }
public double TotalDuration { get; set; }
public string Cover { get; set; } = string.Empty;
public bool HasSubFolders => SubFolderCount > 0;
}

/// <summary>
/// Represents a rule for splitting or categorizing artist names in the Tunetastic application. <br/>
/// The rule can be configured as either a "Splitter" to break apart artist names, or an "Exception" to preserve specific artist names intact. <br/>
Expand Down
312 changes: 312 additions & 0 deletions Common/Operations/FolderOperations.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,312 @@
namespace Tunetastic.Common.Operations;

/// <summary>
/// Provides operations for discovering, grouping, and navigating music folders across libraries.
/// Supports both flat directory listings and explorer-style hierarchical folder browsing.
/// </summary>
public static class FolderOperations
{
/// <summary>
/// Normalizes a directory path by trimming leading/trailing whitespace, removing trailing slashes,
/// and standardizing directory separators.
/// </summary>
/// <param name="path">The directory path to normalize.</param>
/// <returns>A normalized directory path string.</returns>
public static string NormalizeFolderPath(string path)
{
if (string.IsNullOrWhiteSpace(path)) return string.Empty;
var trimmed = path.Trim().TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
return trimmed.Replace('/', '\\');
}

/// <summary>
/// Determines whether any ancestor directory of <paramref name="dir"/> is present in the provided set of music folders.
/// </summary>
/// <param name="dir">The normalized directory path to check.</param>
/// <param name="musicDirs">The set of all normalized directories that contain music.</param>
/// <returns><c>true</c> if an ancestor directory contains music files; otherwise, <c>false</c>.</returns>
public static bool HasAncestorFolder(string dir, HashSet<string> musicDirs)
{
var parent = Path.GetDirectoryName(dir);
while (!string.IsNullOrEmpty(parent))
{
var normalizedParent = NormalizeFolderPath(parent);
if (musicDirs.Contains(normalizedParent))
return true;
parent = Path.GetDirectoryName(parent);
}
return false;
}

/// <summary>
/// Mode 1 (All Music Folders): Retrieves all folders directly containing music files, with no hierarchy checking.
/// </summary>
/// <param name="ascending">Specifies whether folders should be sorted in ascending or descending alphabetical order.</param>
/// <returns>A list of <see cref="FolderModel"/> objects representing all folders directly containing music files.</returns>
public static async Task<List<FolderModel>> GetFoldersFlatAsync(bool ascending = true)
{
try
{
var songs = await DatabaseHelper.Instance.GetSongPathsWithMetadataAsync();
var groups = songs
.Where(s => !string.IsNullOrEmpty(s.Path))
.GroupBy(s => NormalizeFolderPath(Path.GetDirectoryName(s.Path) ?? string.Empty), StringComparer.OrdinalIgnoreCase)
.Where(g => !string.IsNullOrEmpty(g.Key));

var folders = new List<FolderModel>();
foreach (var g in groups)
{
var dirPath = g.Key;
var dirName = Path.GetFileName(dirPath);
if (string.IsNullOrEmpty(dirName)) dirName = dirPath;

var cover = g.FirstOrDefault(s => !string.IsNullOrEmpty(s.Cover) && !s.Cover.EndsWith(Constants.DefaultCoverFileName, StringComparison.OrdinalIgnoreCase))?.Cover
?? g.FirstOrDefault(s => !string.IsNullOrEmpty(s.Cover))?.Cover ?? string.Empty;

folders.Add(new FolderModel
{
Name = dirName,
Path = dirPath,
Count = g.Count(),
TotalSongCount = g.Count(),
SubFolderCount = 0,
TotalDuration = g.Sum(s => s.Duration),
Cover = cover
});
}

return ascending
? folders.OrderBy(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList()
: folders.OrderByDescending(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList();
}
catch (Exception)
{
return new List<FolderModel>();
}
}

/// <summary>
/// Mode 2 (Folder Hierarchy): Retrieves root folders that contain music files (where no ancestor contains music files).
/// Empty intermediate container folders that contain no direct or descendant music files are excluded.
/// </summary>
/// <param name="ascending">Specifies whether folders should be sorted in ascending or descending alphabetical order.</param>
/// <returns>A list of top-level <see cref="FolderModel"/> root folders.</returns>
private static List<FolderModel>? _cachedRootFolders;
private static readonly System.Collections.Concurrent.ConcurrentDictionary<string, List<FolderModel>> _subfoldersCache = new(StringComparer.OrdinalIgnoreCase);

/// <summary>
/// Gets the cached list of root folders in hierarchical mode, if available.
/// </summary>
public static List<FolderModel>? CachedRootFolders => _cachedRootFolders;

/// <summary>
/// Clears the cached root folders.
/// </summary>
public static void InvalidateCache()
{
_cachedRootFolders = null;
_subfoldersCache.Clear();
}

public static async Task<List<FolderModel>> GetRootFoldersHierarchicalAsync(bool ascending = true)
{
try
{
if (_cachedRootFolders != null)
{
return ascending
? _cachedRootFolders.OrderBy(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList()
: _cachedRootFolders.OrderByDescending(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList();
}

var songs = await DatabaseHelper.Instance.GetSongPathsWithMetadataAsync();
var directGroups = songs
.Where(s => !string.IsNullOrEmpty(s.Path))
.GroupBy(s => NormalizeFolderPath(Path.GetDirectoryName(s.Path) ?? string.Empty), StringComparer.OrdinalIgnoreCase)
.Where(g => !string.IsNullOrEmpty(g.Key))
.ToDictionary(g => g.Key, g => g.ToList(), StringComparer.OrdinalIgnoreCase);

var musicDirs = directGroups.Keys.ToHashSet(StringComparer.OrdinalIgnoreCase);
var rootDirs = musicDirs.Where(d => !HasAncestorFolder(d, musicDirs)).ToList();

var folders = new List<FolderModel>();
foreach (var rootDir in rootDirs)
{
var songsInTree = songs.Where(s =>
{
var sDir = NormalizeFolderPath(Path.GetDirectoryName(s.Path) ?? string.Empty);
return LibraryScanner.IsSameOrNestedPath(sDir, rootDir);
}).ToList();

var immediateSubfolders = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var md in musicDirs)
{
if (!md.Equals(rootDir, StringComparison.OrdinalIgnoreCase) && LibraryScanner.IsSameOrNestedPath(md, rootDir))
{
var relative = md.Substring(rootDir.Length).TrimStart('\\', '/');
var firstSegment = relative.Split('\\', '/')[0];
if (!string.IsNullOrEmpty(firstSegment))
immediateSubfolders.Add(firstSegment);
}
}

var dirName = Path.GetFileName(rootDir);
if (string.IsNullOrEmpty(dirName)) dirName = rootDir;

var cover = songsInTree.FirstOrDefault(s => !string.IsNullOrEmpty(s.Cover) && !s.Cover.EndsWith(Constants.DefaultCoverFileName, StringComparison.OrdinalIgnoreCase))?.Cover
?? songsInTree.FirstOrDefault(s => !string.IsNullOrEmpty(s.Cover))?.Cover ?? string.Empty;

folders.Add(new FolderModel
{
Name = dirName,
Path = rootDir,
Count = directGroups.TryGetValue(rootDir, out var dg) ? dg.Count : 0,
TotalSongCount = songsInTree.Count,
SubFolderCount = immediateSubfolders.Count,
TotalDuration = songsInTree.Sum(s => s.Duration),
Cover = cover
});
}

_cachedRootFolders = folders;
return ascending
? folders.OrderBy(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList()
: folders.OrderByDescending(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList();
}
catch (Exception)
{
return new List<FolderModel>();
}
}

/// <summary>
/// In Mode 2 (Folder Hierarchy): Retrieves immediate child subfolders under <paramref name="parentFolderPath"/> that lead to music tracks.
/// </summary>
/// <param name="parentFolderPath">The parent directory path whose subfolders should be retrieved.</param>
/// <param name="ascending">Specifies whether folders should be sorted in ascending or descending alphabetical order.</param>
/// <returns>A list of <see cref="FolderModel"/> objects representing immediate child subfolders.</returns>
public static async Task<List<FolderModel>> GetSubFoldersAsync(string parentFolderPath, bool ascending = true)
{
try
{
var normalizedParent = NormalizeFolderPath(parentFolderPath);

if (_subfoldersCache.TryGetValue(normalizedParent, out var cached))
{
return ascending
? cached.OrderBy(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList()
: cached.OrderByDescending(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList();
}

var songs = await DatabaseHelper.Instance.GetSongPathsWithMetadataAsync();
var directGroups = songs
.Where(s => !string.IsNullOrEmpty(s.Path))
.GroupBy(s => NormalizeFolderPath(Path.GetDirectoryName(s.Path) ?? string.Empty), StringComparer.OrdinalIgnoreCase)
.Where(g => !string.IsNullOrEmpty(g.Key))
.ToDictionary(g => g.Key, g => g.ToList(), StringComparer.OrdinalIgnoreCase);

var musicDirs = directGroups.Keys.ToHashSet(StringComparer.OrdinalIgnoreCase);

var subfolderSegments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var md in musicDirs)
{
if (!md.Equals(normalizedParent, StringComparison.OrdinalIgnoreCase) && LibraryScanner.IsSameOrNestedPath(md, normalizedParent))
{
var relative = md.Substring(normalizedParent.Length).TrimStart('\\', '/');
var firstSegment = relative.Split('\\', '/')[0];
if (!string.IsNullOrEmpty(firstSegment) && !subfolderSegments.ContainsKey(firstSegment))
{
subfolderSegments[firstSegment] = Path.Combine(normalizedParent, firstSegment);
}
}
}

var subfolders = new List<FolderModel>();
foreach (var kvp in subfolderSegments)
{
var subName = kvp.Key;
var subPath = kvp.Value;

var songsInSubTree = songs.Where(s =>
{
var sDir = NormalizeFolderPath(Path.GetDirectoryName(s.Path) ?? string.Empty);
return LibraryScanner.IsSameOrNestedPath(sDir, subPath);
}).ToList();

var nestedSubfolders = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var md in musicDirs)
{
if (!md.Equals(subPath, StringComparison.OrdinalIgnoreCase) && LibraryScanner.IsSameOrNestedPath(md, subPath))
{
var relative = md.Substring(subPath.Length).TrimStart('\\', '/');
var first = relative.Split('\\', '/')[0];
if (!string.IsNullOrEmpty(first))
nestedSubfolders.Add(first);
}
}

var cover = songsInSubTree.FirstOrDefault(s => !string.IsNullOrEmpty(s.Cover) && !s.Cover.EndsWith(Constants.DefaultCoverFileName, StringComparison.OrdinalIgnoreCase))?.Cover
?? songsInSubTree.FirstOrDefault(s => !string.IsNullOrEmpty(s.Cover))?.Cover ?? string.Empty;

subfolders.Add(new FolderModel
{
Name = subName,
Path = subPath,
Count = directGroups.TryGetValue(subPath, out var dg) ? dg.Count : 0,
TotalSongCount = songsInSubTree.Count,
SubFolderCount = nestedSubfolders.Count,
TotalDuration = songsInSubTree.Sum(s => s.Duration),
Cover = cover
});
}

_subfoldersCache[normalizedParent] = subfolders;
return ascending
? subfolders.OrderBy(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList()
: subfolders.OrderByDescending(f => f.Name, StringComparer.OrdinalIgnoreCase).ToList();
}
catch (Exception)
{
return new List<FolderModel>();
}
}

/// <summary>
/// Retrieves songs located in a specific folder (optionally including all subfolders).
/// </summary>
/// <param name="folderPath">The directory path to query songs for.</param>
/// <param name="includeSubfolders"><c>true</c> to include songs from subdirectories; <c>false</c> for direct contents only.</param>
/// <param name="orderBy">The song property to order by.</param>
/// <param name="ascending">Specifies whether sorting is ascending or descending.</param>
/// <returns>A list of <see cref="Song"/> objects matching the folder criteria.</returns>
public static async Task<List<Song>> GetSongsInFolderAsync(string folderPath, bool includeSubfolders = false, SongProperty orderBy = SongProperty.Title, bool ascending = true)
{
try
{
var normalized = NormalizeFolderPath(folderPath);

var songs = await DatabaseHelper.Instance.LoadSongsFromDB(orderBy: orderBy, ascending: ascending);
if (includeSubfolders)
{
return songs.Where(s =>
{
var dir = NormalizeFolderPath(Path.GetDirectoryName(s.Path) ?? string.Empty);
return LibraryScanner.IsSameOrNestedPath(dir, normalized);
}).ToList();
}
else
{
return songs.Where(s =>
{
var dir = NormalizeFolderPath(Path.GetDirectoryName(s.Path) ?? string.Empty);
return dir.Equals(normalized, StringComparison.OrdinalIgnoreCase);
}).ToList();
}
}
catch (Exception)
{
return new List<Song>();
}
}
}

3 changes: 2 additions & 1 deletion Common/Operations/LibraryScanner.cs
Original file line number Diff line number Diff line change
Expand Up @@ -77,6 +77,7 @@ public async Task UpdateMetaData()
}

_isScanning = false;
FolderOperations.InvalidateCache();
MusicPlayer.Instance.ResetOrReloadPlayer();
TaskbarHelper.SetProgressState(App.Hwnd, TaskbarStates.NoProgress);
}
Expand Down Expand Up @@ -404,7 +405,7 @@ internal static List<string> ComputeEffectiveRoots(List<string> libraries)
/// The comparison is separator aware, so sibling folders that only share a name prefix
/// (e.g. "D:\Music" and "D:\Music2") are not mistaken for nested ones and silently dropped.
/// </remarks>
private static bool IsSameOrNestedPath(string path, string parent)
internal static bool IsSameOrNestedPath(string path, string parent)
{
var trimmedParent = parent.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);

Expand Down
Loading
Loading