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); }