|
private GetFoldersAsync ( ) : IAsyncOperation |
||
| return | IAsyncOperation |
|
private async void GetAllFiles(StorageFolder folder, ObservableCollection<Song> songs)
{
foreach (StorageFile file in await folder.GetFilesAsync())
{
if(file.FileType == ".mp3")
{
var props = await file.Properties.GetMusicPropertiesAsync();
var image = await file.GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.MusicView);
var cover = new BitmapImage();
cover.SetSource(image);
Song song = new Song()
{
Name = props.Title,
Album = props.Album,
Artist = props.Artist,
Cover = cover,
File = file
};
songs.Add(song);
}
}
foreach (StorageFolder subfolder in await folder.GetFoldersAsync())
{
GetAllFiles(subfolder, songs);
}
}
public async Task getFiles(List<StorageFile> list, StorageFolder parent)
{ //get all files of type folder search use Recursion
foreach (var item in await parent.GetFilesAsync())
{
list.Add(item);
}
foreach (var item in await parent.GetFoldersAsync())
await getFiles(list, item);
}
public async Task getFiles(List<StorageFile> list, StorageFolder parent)
{
foreach (var item in await parent.GetFilesAsync())
{
list.Add(item);
}
foreach (var item in await parent.GetFoldersAsync())
await getFiles(list, item);
}
private async void folderInitialisation(StorageFolder picturesFolder)
{
IReadOnlyList<StorageFolder> folderList = await picturesFolder.GetFoldersAsync();
StringBuilder folderString = new StringBuilder(picturesFolder.Name + "\n\n");
foreach (StorageFolder folder in folderList)
{
folderString.AppendLine(" " + folder.DisplayName + "\\");
}
folderText.Text = folderString.ToString();
}
internal async static Task MergeFolders(StorageFolder source, StorageFolder target)
{
foreach (StorageFile sourceFile in await source.GetFilesAsync())
{
await sourceFile.CopyAndReplaceAsync(await target.CreateFileAsync(sourceFile.Name, CreationCollisionOption.OpenIfExists));
}
foreach (StorageFolder sourceDirectory in await source.GetFoldersAsync())
{
StorageFolder nextTargetSubDir = await target.CreateFolderAsync(sourceDirectory.Name, CreationCollisionOption.OpenIfExists);
await MergeFolders(sourceDirectory, nextTargetSubDir);
}
}
private async Task retrieveFilesInFolders(ObservableCollection<StorageFile> list,StorageFolder parent)
{
foreach (var item in await parent.GetFilesAsync())
{
if (item.FileType == ".mp3")
list.Add(item);
}
foreach (var item in await parent.GetFoldersAsync())
{
await retrieveFilesInFolders(list, item);
}
}
async Task<List<string>> _getAllFilesInFolderRecurse(StorageFolder currentFolder, string topFolder)
{
List<string> files = new List<string>();
foreach (var f in await currentFolder.GetFoldersAsync())
{
files.AddRange(await _getAllFilesInFolderRecurse(f, topFolder));
}
var filesResult = await currentFolder.GetFilesAsync();
var filesString = filesResult.Select(_ => _.Path.Replace(topFolder, "").Trim('\\')).ToList();
files.AddRange(filesString);
return files;
}
/// <summary>
/// Returns the number of files within the Oxford Whitelist
/// </summary>
public static async Task<int> GetFileCountInWhitelist(StorageFolder folder)
{
int fileCount = 0;
fileCount += (await folder.GetFilesAsync()).Count;
var subFolders = await folder.GetFoldersAsync();
foreach(var subFolder in subFolders)
{
fileCount += (await subFolder.GetFilesAsync()).Count;
}
return fileCount;
}
// first - a method to retrieve files from folder recursively
private static async Task RetriveFilesInFolder(List<StorageFile> list, StorageFolder parent)
{
list.AddRange((await parent.GetFilesAsync()).Where(p =>
p.FileType == ".wma"
|| p.FileType == ".flac"
|| p.FileType == ".m4a"
|| p.FileType == ".mp3"));
//avoiding DRM folder of xbox music
foreach (var folder in (await parent.GetFoldersAsync()).Where(folder =>
folder.Name != "Xbox Music" && folder.Name != "Subscription Cache" && folder.Name != "Podcasts"))
{
await RetriveFilesInFolder(list, folder);
}
}
private async Task DeleteFolderRecursivelyAsync(StorageFolder folder)
{
IReadOnlyList<StorageFolder> folders = await folder.GetFoldersAsync();
if (folders.Count > 0)
{
foreach (StorageFolder subFolder in folders)
{
await DeleteFolderRecursivelyAsync(subFolder);
}
}
IReadOnlyList<StorageFile> files = await folder.GetFilesAsync();
foreach (StorageFile file in files)
{
await file.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
}
public async void GetAllFolders(StorageFolder KnownFolders)
{
IReadOnlyList<StorageFolder> folderList = await KnownFolders.GetFoldersAsync();
// Pluck off meta data from folders
int id = 0;
foreach (StorageFolder folder in folderList)
{
Folder Folder = new Folder();
Folder.Id = id;
Folder.Name = folder.Name;
Folder.Path = folder.Path;
Folder.FolderFile = folder;
Folders.Add(Folder);
id++;
}
}
internal async static Task<string> FindJSBundleInUpdateContents(StorageFolder updateFolder, string expectedFileName)
{
foreach (StorageFile file in await updateFolder.GetFilesAsync())
{
string fileName = file.Name;
if (fileName.Equals(expectedFileName))
{
return fileName;
}
}
foreach (StorageFolder folder in await updateFolder.GetFoldersAsync())
{
string mainBundlePathInSubFolder = await FindJSBundleInUpdateContents(folder, expectedFileName);
if (mainBundlePathInSubFolder != null)
{
return Path.Combine(folder.Name, mainBundlePathInSubFolder);
}
}
return null;
}
public async Task ListFilesInFolder(StorageFolder folder)
{
var foldersInFolder = await folder.GetFoldersAsync();
foreach (StorageFolder currentChildFolder in foldersInFolder)
{
await ListFilesInFolder(currentChildFolder);
}
var filesInFolder = await folder.GetFilesAsync();
foreach (StorageFile currentFile in filesInFolder)
{
if (currentFile.ContentType.IsImageFormat())
{
var picture = new Picture(currentFile.Name, currentFile.DateCreated.DateTime, currentFile.Path);
if (!pictures.Contains(picture))
{
pictures.Add(picture);
await picture.LoadImageAsync();
}
}
}
}
public static async Task resetFolders()
{
Windows.Storage.StorageFolder localfolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile firstfile = await localfolder.GetFileAsync("firsttime");
await firstfile.DeleteAsync();
var folders = await localfolder.GetFoldersAsync();
foreach (Windows.Storage.StorageFolder folder in folders)
{
await folder.DeleteAsync();
}
Windows.Storage.StorageFolder stor = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync("thumbs", Windows.Storage.CreationCollisionOption.FailIfExists);
Uri uri = new Uri("ms-appx:///Assets/bookImage.jpg");
Windows.Storage.StorageFile file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(uri);
Windows.Storage.StorageFolder imageFolder = await Windows.Storage.ApplicationData.Current.LocalFolder.GetFolderAsync("thumbs");
await file.CopyAsync(imageFolder, "default.jpg");
}
/// <summary>
/// ZipFolder and its sub folders
/// </summary>
/// <param name="tcpSocket"></param>
async private static Task ZipFolderContents(StorageFolder sourceFolder, ZipArchive archive, string baseDirPath)
{
IReadOnlyList<StorageFile> files = await sourceFolder.GetFilesAsync();
foreach (StorageFile file in files)
{
ZipArchiveEntry readmeEntry = archive.CreateEntry(GetCompressedFileName(baseDirPath, file));
byte[] buffer = WindowsRuntimeBufferExtensions.ToArray(await FileIO.ReadBufferAsync(file));
// And write the contents to it
using (Stream entryStream = readmeEntry.Open())
{
await entryStream.WriteAsync(buffer, 0, buffer.Length);
}
}
IReadOnlyList<StorageFolder> subFolders = await sourceFolder.GetFoldersAsync();
if (subFolders.Count() == 0) return;
foreach (StorageFolder subfolder in subFolders)
await ZipFolderContents(subfolder, archive, baseDirPath);
}
public async System.Threading.Tasks.Task<uint> BrowseFolder(StorageFolder folder)
{
// LogMessage("Discover folder Name: " + folder.Name + " Path: " + folder.Path + " files: [" + fileDiscovered + "] folders: [" + folderDiscovered + "]");
folderDiscovered++;
if (ProgressEvent != null)
ProgressEvent(folderDiscovered);
await System.Threading.Tasks.Task.Delay(100);
try
{
if (discoverCancelToken != null)
if (discoverCancelToken.Token.IsCancellationRequested)
discoverCancelToken.Token.ThrowIfCancellationRequested();
IReadOnlyList<StorageFolder> folders = await folder.GetFoldersAsync(CommonFolderQuery.DefaultQuery);
foreach (var f in folders)
{
if (discoverCancelToken != null)
if (discoverCancelToken.Token.IsCancellationRequested)
discoverCancelToken.Token.ThrowIfCancellationRequested();
uint value = await BrowseFolder(f);
}
}
catch (Exception e)
{
LogMessage("Discover folder exception: " + folder.Path + " Exception:" + e.Message);
}
uint currentFilesDiscovered = fileDiscovered;
try
{
if (discoverCancelToken != null)
if (discoverCancelToken.Token.IsCancellationRequested)
discoverCancelToken.Token.ThrowIfCancellationRequested();
// IReadOnlyList<StorageFile> files = await folder.GetFilesAsync(CommonFileQuery.OrderByName);
IReadOnlyList<StorageFile> files = await folder.GetFilesAsync(CommonFileQuery.DefaultQuery);
foreach (var f in files)
{
if (discoverCancelToken != null)
if (discoverCancelToken.Token.IsCancellationRequested)
discoverCancelToken.Token.ThrowIfCancellationRequested();
string path = await GetPath(f);
string extension = f.FileType;
foreach (string e in extensionArray)
{
if (extension.EndsWith(e, StringComparison.CurrentCultureIgnoreCase))
{
if (!defaultMediaDictionary.ContainsKey(path))
{
MediaLibraryItem mli = new MediaLibraryItem(path);
defaultMediaDictionary.Add(path, mli);
fileDiscovered = (uint)defaultMediaDictionary.Count;
}
UpdateUI();
//statusValue.Text = fileDiscovered.ToString() + " files discovered";
// LogMessage("Discover file name: " + f.Name + " path: " + path);
break;
}
}
}
}
catch (Exception e)
{
LogMessage("Discover files exception: " + folder.Path + " Exception:" + e.Message);
}
if (currentFilesDiscovered != fileDiscovered)
{
UpdateCounter();
}
return fileDiscovered;
}
private async Task<List<StorageFile>> RecursivelySearchForFiles(StorageFolder destFolder)
{
List<StorageFile> filesList = new List<StorageFile>();
IReadOnlyList<StorageFile> files = await destFolder.GetFilesAsync();
IReadOnlyList<StorageFolder> folders = await destFolder.GetFoldersAsync();
foreach (StorageFile file in files)
{
if (file.FileType == ".cbz" || file.FileType == ".cbr" || file.FileType == "cbz" || file.FileType == "cbr")
filesList.Add(file);
}
foreach(StorageFolder folder in folders)
{
List<StorageFile> tempFiles = await RecursivelySearchForFiles(folder);
foreach (StorageFile file in tempFiles)
if (file.FileType == ".cbz" || file.FileType == ".cbr" || file.FileType == "cbz" || file.FileType == "cbr")
filesList.Add(file);
}
return filesList;
}
async Task<string> FolderCrawler(StorageFolder sf, string folderpath, bool crawl = true, bool addpath = true)
{
var files = await sf.GetFilesAsync();
var folders = await sf.GetFoldersAsync();
string outs = string.Empty;
if (string.IsNullOrEmpty(folderpath)) outs += "directory: \n";
else outs += "directory: " + folderpath + "\n";
foreach (StorageFile file in files)
{
if (file.FileType.ToLower().Equals(".mp3") ||
file.FileType.ToLower().Equals(".wav") ||
file.FileType.ToLower().Equals(".wma"))
{
SongTag songTag = await SongTag.GetSongTagFromFile(file);
if (addpath)
{
if (string.IsNullOrEmpty(folderpath)) songTag.file = sf.Name + "/" + file.Name; // + "\n";
else songTag.file = folderpath + "/" + file.Name; // +"\n";
}
else {
songTag.file = file.Name; // +"\n";
}
outs += songTag.ToString();
}
}
foreach(StorageFolder folder in folders)
{
string fpath = string.Empty;
if (string.IsNullOrEmpty(folderpath)) fpath = folder.Name;
else fpath = folderpath + "/" + folder.Name;
if(crawl) outs += await FolderCrawler(folder, fpath);
}
return outs;
}
private async Task<List<File>> UpdateDb(StorageFolder currentfolder, Directory parentDirectory, List<string> relativepath)
{
List<File> songlist = new List<File>();
//
// Get all files and sub folders in current folder
//
var files = await currentfolder.GetFilesAsync();
//
// Get all files matching the avaible playback froamts
//
var matchingFiles = files.Where<StorageFile>(o => allowedFileTypes.Contains<string>(o.FileType.ToLower()));
var folders = await currentfolder.GetFoldersAsync();
//
// Add the current foldername to list of relativepaths
//
relativepath.Add(currentfolder.DisplayName);
//
// Get the full current relative path
//
string currentrelativepath = string.Empty;
for (int i = 0; i < relativepath.Count; i++)
{
currentrelativepath += relativepath[i];
currentrelativepath += (i < relativepath.Count - 1 && i > 0) ? "/" : string.Empty;
}
//
// Check if the Folder already exist, if not create the folder
//
if (await GetDirectory(currentfolder.DisplayName, parentDirectory.DirectoryId) == null)
{
//
// Create new Directory from current folder
//
Directory newDirectory = new Directory()
{
Name = currentfolder.DisplayName,
Path = currentfolder.Path,
RelativePath = currentrelativepath,
ParentDirectoryId = parentDirectory.DirectoryId,
FolderRelativeId = currentfolder.FolderRelativeId
};
//
// Add the Directory for current folder to Directories
//
await Dbconnection.InsertAsync(newDirectory);
}
//
// Get the Directory for the current folder
//
Directory currentDirectory = await GetDirectory(currentfolder.DisplayName, parentDirectory.DirectoryId) ;
//
// Check if files don't exist in the filesystem any more and remove the files from the database
//
var currentDirectoryFiles = await Dbconnection.QueryAsync<File>("SELECT * FROM Files WHERE DirectoryId = " + currentDirectory.DirectoryId);
//
// Get any files to remove
//
IEnumerable<File> filestoremove =
from cfile in currentDirectoryFiles
where !((from file in matchingFiles select file.Name).ToList<string>().Contains<string>(cfile.Name))
select cfile;
//
// Remove files that don't exist on filesystem anymore
//
foreach (File removefile in filestoremove)
{
await Dbconnection.DeleteAsync(removefile);
}
//
// Check if files don't exist in any more in filesystem and remove the files from the database
//
var currentSubDirectory = await Dbconnection.QueryAsync<Directory>("SELECT * FROM Directories WHERE ParentDirectoryId = " + currentDirectory.DirectoryId);
//
// Get any directories to remove
//
IEnumerable<Directory> directroiesstoremove =
from cDirectory in currentSubDirectory
where !((from folder in folders
select folder.DisplayName).ToList<string>().Contains<string>(cDirectory.Name))
select cDirectory;
//
// Remove directories that don't exist on filesystem anymore
//
foreach (Directory removedirectory in directroiesstoremove)
{
List<Directory> subDirToRemove = await GetSubDirectories(removedirectory);
foreach(Directory d in subDirToRemove)
{
var removesubdirectoryFiles = await Dbconnection.QueryAsync<File>("SELECT * FROM Files WHERE DirectoryId = " + d.DirectoryId);
foreach (File f in removesubdirectoryFiles)
{
await Dbconnection.DeleteAsync(f);
}
await Dbconnection.DeleteAsync(d);
}
var removedirectoryFiles = await Dbconnection.QueryAsync<File>("SELECT * FROM Files WHERE DirectoryId = " + removedirectory.DirectoryId);
foreach(File f in removedirectoryFiles)
{
await Dbconnection.DeleteAsync(f);
}
await Dbconnection.DeleteAsync(removedirectory);
}
foreach (StorageFile storagefile in matchingFiles)
{
//
// Check if the file aready exist in the database, if not the add the file
//
if (await GetFile(storagefile.Name, currentDirectory.DirectoryId) == null)
{
Windows.Storage.FileProperties.MusicProperties mp = null;
int? bitrate = null;
mp = mp ?? await storagefile.Properties.GetMusicPropertiesAsync();
Tuple<int, string> genre = await GetGenreId(mp.Genre);
File newFile = new File()
{
Name = storagefile.Name,
FilePath = storagefile.Path,
DirectoryId = currentDirectory.DirectoryId,
RelativePath = (string.IsNullOrEmpty(currentrelativepath)) ? storagefile.Name : currentrelativepath + "/" + storagefile.Name,
Title = mp.Title,
Date = (mp.Year > 0) ? mp.Year.ToString() : string.Empty,
AlbumArtist = mp.AlbumArtist,
Time = Convert.ToInt32(mp.Duration.TotalSeconds),
Disc = -1,
PositionId = -1,
Prio = 0,
Pos = 0,
LastModified = storagefile.DateCreated.ToString(),
Track = Convert.ToInt32(mp.TrackNumber),
Album = mp.Album,
Artist = mp.Artist,
Genre = genre.Item2,
GenreId = genre.Item1,
AlbumId = await GetAlbumId(mp.Album),
ArtistId = await GetArtistId(mp.Artist),
FolderRelativeId = storagefile.FolderRelativeId,
Bitrate = bitrate ?? Convert.ToInt32(mp.Bitrate),
Type = "File"
};
songlist.Add(newFile);
}
}
//
// Loop through sub folders and add any files to current songlist
//
foreach (StorageFolder folder in folders)
{
songlist.AddRange(await UpdateDb(folder, currentDirectory, relativepath));
}
//
// Remove this current folder from relativepaths
//
if (relativepath.Count > 0) relativepath.RemoveAt(relativepath.Count - 1);
return songlist;
}
private void GetAllFiles(StorageFolder storageFolder, List<StorageFile> musicFiles)
{
foreach (var file in Task.Run(async () => await storageFolder.GetFilesAsync()).Result)
if (file.ContentType.StartsWith("audio") && !file.ContentType.EndsWith("url"))
musicFiles.Add(file);
foreach (var folder in Task.Run(async () => await storageFolder.GetFoldersAsync()).Result)
this.GetAllFiles(folder, musicFiles);
}
/// <summary>
/// Generates html for the gallery
/// </summary>
/// <param name="folder">Folder to read the pictures from</param>
/// <param name="pageNumber">Page starting from 1</param>
/// <param name="pageSize">Number of pictures on each page</param>
/// <returns></returns>
public async Task<string> GenerateGallery(StorageFolder folder, int pageNumber, int pageSize)
{
// Don't allow negatives
if (pageNumber < 1) pageNumber = 1;
if (pageSize < 1) pageSize = 1;
var subFolders = await folder.GetFoldersAsync();
var parentFolder = await folder.GetParentAsync();
// JavaScript code for toggling the subfolder list
string html = "";
html += "<script type='text/javascript'>" +
"function toggleSubfolderList(){"+
"var folderNavPane = document.getElementById('folder_nav_pane');" +
"if(folderNavPane.style.display == 'block') folderNavPane.style.display = 'none';" +
"else folderNavPane.style.display = 'block'" +
"}" +
"</script>";
html += "<table>";
html += "<tr><td>";
// Create breadcrumbs for folder nav
var temp = folder;
string breadcrumbs = "<b>"+ ((subFolders.Count > 0) ? "<a onclick='toggleSubfolderList()' href='javascript:void(0);'>" + temp.Name + "</a>" : temp.Name) + "</b>";
while(!temp.Path.Equals(rootFolder.Path, StringComparison.OrdinalIgnoreCase))
{
temp = await temp.GetParentAsync();
string hyperlink = MakeHyperlink(temp.Name, "/gallery.htm?folder=" + WebUtility.UrlEncode(temp.Path), false);
breadcrumbs = hyperlink + " > " + breadcrumbs;
}
html += breadcrumbs + "<br>";
if (subFolders.Count > 0)
{
// Generate subfolder navigation pane
html += "<div id='folder_nav_pane' style='display:none'>";
html += "<ul>";
foreach (StorageFolder subFolder in subFolders)
{
html += "<li><a href='/gallery.htm?folder=" + WebUtility.UrlEncode(subFolder.Path) + "'>" + subFolder.Name + "</a></li>";
}
html += "</ul></div>";
}
html += "<br></td></tr>";
// Get the files in current folder and subfolders
var queryOptions = new QueryOptions();
queryOptions.FolderDepth = FolderDepth.Deep;
var results = folder.CreateFileQueryWithOptions(queryOptions);
StorageFile[] sortedFiles = null;
// Use cached files if we already got the files and we're navigating to the first page
if (cachedFiles != null && pageNumber != 1)
{
sortedFiles = cachedFiles;
}
else
{
var files = await results.GetFilesAsync();
sortedFiles = files.OrderByDescending((x) => x.DateCreated).ToArray();
cachedFiles = sortedFiles;
}
if (sortedFiles.Length > 0)
{
// Create pages
string pagesHtml = "<form>";
html += "<tr><td>";
int totalPages = (int)Math.Ceiling((double)sortedFiles.Length / pageSize);
pagesHtml += "Pages: ";
pagesHtml += "<select name='page' onchange='this.form.submit()'>";
for (int i = 1; i <= totalPages; i++)
{
pagesHtml += "<option value='" + i + "' " + ((i == pageNumber) ? "selected='selected'" : "") + ">" + i + "</option>";
}
pagesHtml += "</select>";
pagesHtml += "<input type='hidden' name='folder' value='" + folder.Path + "' />";
pagesHtml += "<input type='hidden' name='pageSize' value='30' />";
pagesHtml += "</form>";
html += pagesHtml;
html += "<br></td></tr>";
html += "<tr><td>";
// Pick out the subset of files we need based on page
int startIndex = (pageNumber - 1) * pageSize;
for (int i = startIndex; i < startIndex + pageSize; i++)
{
if (i < sortedFiles.Length)
{
StorageFile file = sortedFiles[i];
html += "<div class='img'>";
html += "<a target='_blank' href='/api/gallery/" + WebUtility.UrlEncode(file.Path) + "'>";
html += "<img src='/api/gallery/" + WebUtility.UrlEncode(file.Path) + "' alt='" + file.Name + "' width='190'>";
html += "<div class='desc'><b>File Name:</b> " + file.Name + "<br><b>Date Created:</b> " + file.DateCreated + "</div>";
html += "</a>";
html += "</div>";
}
}
html += "</td></tr>";
// Create pages
html += "<tr><td>";
html += "<br>" + pagesHtml;
html += "</td></tr>";
}
else
{
html += "No pictures found in " + folder.Path;
}
html += "</table>";
return html;
}
private async Task LoadRoutes()
{
RoutesFolder = await ApplicationData.Current.RoamingFolder.CreateFolderAsync("Routes", CreationCollisionOption.OpenIfExists);
IReadOnlyList<StorageFolder> collections = await RoutesFolder.GetFoldersAsync();
// Empty the existing list
library.Items[RoutesIndex].Items.Clear();
filteredLibrary.Items[RoutesIndex].Items.Clear();
foreach (StorageFolder collection in collections)
{
try
{
Collection<object> col = new Collection<object>(collection.DisplayName, "SolidStar");
var RouteFiles = await collection.GetFilesAsync();
foreach (StorageFile file in RouteFiles)
{
FavoriteRoute fav = await new FavoriteRoute().LoadFromFile(file);
fav.Collection = collection.DisplayName;
col.Items.Add(fav);
}
library.Items[RoutesIndex].Items.Add(col);
}
catch (Exception e)
{
throw e;
}
}
// And the unsorted ones
try
{
Collection<object> col = new Collection<object>("Unsortiert", "OutlineStar");
var RouteFiles = await RoutesFolder.GetFilesAsync();
foreach (StorageFile file in RouteFiles)
{
col.Items.Add(await new FavoriteRoute().LoadFromFile(file));
}
library.Items[RoutesIndex].Items.Add(col);
}
catch (Exception e)
{
throw e;
}
}
async private System.Threading.Tasks.Task<uint> BrowseForVideoFiles(StorageFolder folder, List<StorageFile> collectedMediaItems, uint maxFilesToRetrieve)
{
uint cVideoFiles = 0;
if (maxFilesToRetrieve > 0)
{
var files = await folder.GetFilesAsync(CommonFileQuery.DefaultQuery, 0, maxFilesToRetrieve);
foreach (var file in files)
{
if (file.ContentType.Length > 5 && file.ContentType.Substring(0, 5).ToLower() == "video")
{
++cVideoFiles;
mediaSelect.Items.Add(file.DisplayName);
collectedMediaItems.Add(file);
}
}
var folders = await folder.GetFoldersAsync();
foreach (var nextFolder in folders)
{
cVideoFiles += await BrowseForVideoFiles(nextFolder, collectedMediaItems, maxFilesToRetrieve - cVideoFiles);
}
}
return cVideoFiles;
}
private static async Task CreateDatabaseFromMusicFolder(StorageFolder musicFolder)
{
try
{
if (Locator.MediaPlaybackViewModel.ContinueIndexing != null)
{
await Locator.MediaPlaybackViewModel.ContinueIndexing.Task;
Locator.MediaPlaybackViewModel.ContinueIndexing = null;
}
if (musicFolder.Name != Strings.PodcastFolderName)
{
var folders = await musicFolder.GetFoldersAsync();
if (folders.Any())
{
foreach (var storageFolder in folders)
{
await CreateDatabaseFromMusicFolder(storageFolder);
}
}
var folderFiles = await musicFolder.GetFilesAsync();
if (folderFiles != null && folderFiles.Any())
{
foreach (var storageFile in folderFiles)
{
await DiscoverTrackItemOrWaitAsync(storageFile);
}
}
}
}
catch (Exception e)
{
ExceptionHelper.CreateMemorizedException("MusicLibraryManagement.CreateDatabaseFromMusicFolder", e);
}
}
private async Task<List<mlistitem>> open(StorageFolder sf)
{
List<mlistitem> mlist = new List<mlistitem>();
var folderlist = await sf.GetFoldersAsync();
var fileslist = await sf.GetFilesAsync();
StorageItemThumbnail thumbnail;
const uint size = 100;
foreach (StorageFolder sfitem in folderlist)
{
BitmapImage bitmapImage = new BitmapImage();
thumbnail = await sfitem.GetThumbnailAsync(ThumbnailMode.SingleItem, size);
if (thumbnail != null)
{
bitmapImage.SetSource(thumbnail);
mlist.Add(new mlistitem() { txt = sfitem.Name, lfolder = sf, img = bitmapImage });
}
}
foreach (StorageFile sfitem in fileslist)
{
BitmapImage bitmapImage = new BitmapImage();
thumbnail = await sfitem.GetThumbnailAsync(ThumbnailMode.SingleItem, size);
if (thumbnail != null)
{
bitmapImage.SetSource(thumbnail);
mlist.Add(new mlistitem() { txt = sfitem.Name, lfile = sfitem, img = bitmapImage });
}
}
return (mlist);
}
/// <summary>
/// Search folder based on paths, storage folder and option in file storage
/// </summary>
/// <param name="paths">Paths to the folder</param>
/// <param name="storageFolder">Storage Folder</param>
/// <param name="option">Option for the folder</param>
/// <returns>Storage Folder</returns>
private static StorageFolder SearchFolder(String[] paths, StorageFolder storageFolder, int option)
{
if (paths == null || paths.Length <= 0)
{
return storageFolder;
}
var foldersTask = storageFolder.GetFoldersAsync().AsTask();
foldersTask.Wait();
if (foldersTask.Exception != null)
{
throw foldersTask.Exception;
}
IReadOnlyList<StorageFolder> readFolders = foldersTask.Result;
foreach (StorageFolder folder in readFolders)
{
for (int i = 0; i < paths.Length; i++)
{
if (folder.Name.Equals(paths[i], StringComparison.OrdinalIgnoreCase))
{
String[] newPaths = new String[paths.Length - 1];
int count = 0;
for (int j = 1; j < paths.Length; j++)
{
newPaths[count++] = paths[j];
}
return SearchFolder(newPaths, folder, option);
}
}
}
return null;
}
private async Task CopyFiles(StorageFolder pSource, StorageFolder pDestination)
{
foreach (var file in await pSource.GetFilesAsync())
file.CopyAsync(pDestination);
foreach (var folder in await pSource.GetFoldersAsync())
{
var newFolder = await pDestination.CreateFolderAsync(folder.Name);
await CopyFiles(folder, newFolder);
}
}
/// <summary>
/// Will retrieve the full folder and file tree for a folder from the internal storage.
/// </summary>
/// <param name="folder">The instance of the folder for which the tree will be retrieved.</param>
async void GetTreeForInternalFolder(StorageFolder folder)
{
if (!_internalFolderTree.Contains(folder))
_internalFolderTree.Push(folder);
ProcessSelectedItems();
CurrentItems.Clear();
var folderList = await folder.GetFoldersAsync();
foreach (StorageFolder _folder in folderList)
{
FileExplorerItem item = (from c in _selectedItems where c.Path == _folder.Path select c).FirstOrDefault();
FileExplorerItem _addItem = new FileExplorerItem()
{
IsFolder = true,
Name = _folder.Name,
Path = _folder.Path,
Selected = item != null ? true : false
};
CurrentItems.Add(_addItem);
}
var fileList = await folder.GetFilesAsync();
if (fileList != null)
{
foreach (StorageFile _file in fileList)
{
FileExplorerItem item = GetItemFromPath(_file.Path);
if (((ExtensionRestrictions & (Interop.ExtensionRestrictions.Custom | Interop.ExtensionRestrictions.InheritManifest)) != 0) && (Extensions.Count != 0))
{
string extension = Path.GetExtension(_file.Name);
if (Extensions.FindIndex(x => x.Equals(extension, StringComparison.OrdinalIgnoreCase)) != -1)
{
CurrentItems.Add(new FileExplorerItem()
{
IsFolder = false,
Name = _file.Name,
Path = _file.Path,
Selected = item != null ? true : false
});
}
}
else
{
CurrentItems.Add(new FileExplorerItem()
{
IsFolder = false,
Name = _file.Name,
Path = _file.Path,
Selected = item != null ? true : false
});
}
}
}
CurrentPath = _internalFolderTree.First().Path;
}
/// <summary>
/// Opens a folder and recursively creates a TestList from it
/// </summary>
/// <param name="folder"></param>
/// <param name="path"></param>
/// <returns></returns>
public static async Task<TestList> Scan(StorageFolder folder, string path)
{
var toreturn = new TestList();
toreturn.Tests = new List<Test>();
toreturn.FolderName = folder.Name;
path += "/" + toreturn.FolderName;
foreach (var f in await folder.GetFilesAsync())
{
if (f.Name.EndsWith(".py"))
{
toreturn.Tests.AddRange(await TestCrawler.GetTestsFromFile(f, path));
}
}
foreach (var f in await folder.GetFoldersAsync())
{
toreturn.Tests.AddRange((await Scan(f, path)).Tests);
}
return toreturn;
}
public async Task PrintFolderAsync(StorageFolder folder)
{
if (folder != null)
{
count++;
Debug.WriteLine(this.getCount() + "folder : " + PtcEncoder.Decode(folder.Name) + "(" + folder.Path + ")");
IReadOnlyList<StorageFile> fileList = await folder.GetFilesAsync();
IReadOnlyList<StorageFolder> folderList = await folder.GetFoldersAsync();
foreach (StorageFile file in fileList)
{
PrintFile(file);
}
foreach (StorageFolder _folder in folderList)
{
await PrintFolderAsync(_folder);
}
count--;
}
}
async Task<bool> _folderExists(string name, StorageFolder currentFolder)
{
var f = await currentFolder.GetFoldersAsync();
return (f.FirstOrDefault(_ => _.Name == name) != null);
}
