async void LoadStudentDetails()
{
// Check to see if file exists
//Get local storage folder
StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
//create a file query
StorageFileQueryResult fileResults = storageFolder.CreateFileQuery();
//Get all files in the directory
IReadOnlyList <StorageFile> fileList = await fileResults.GetFilesAsync();
//check to see if we have a file
studentsFile = fileList.SingleOrDefault(file => file.Name == "students.txt");
if (studentsFile == null)
{
//if not create
studentsFile = await storageFolder.CreateFileAsync("students.txt");
}
else
{
//else load from a stream
using (StreamReader reader = new StreamReader(await studentsFile.OpenStreamForReadAsync()))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
Student student = new Student();
student.parse(line);
RegisteredStudents.Add(student);
}
}
}
}
/// <summary>
/// 扫描本地Music Library的所有音乐
/// </summary>
/// <returns>返回所有的音乐文件属性和相对music library的路径</returns>
public static async Task <List <MusicPropertiesWithPath> > ScanLocalMusicInLibrary()
{
StorageFolder folder = KnownFolders.MusicLibrary;
List <MusicPropertiesWithPath> songs = new List <MusicPropertiesWithPath>();
StorageFileQueryResult query = folder.CreateFileQuery(CommonFileQuery.OrderByMusicProperties);
//var files = await folder.GetFilesAsync(Windows.Storage.Search.CommonFileQuery.OrderByMusicProperties);
var files = await query.GetFilesAsync();
foreach (var file in files)
{
var properties = await file.Properties.GetMusicPropertiesAsync();
try
{
using (var stream = await file.OpenReadAsync())
{
songs.Add(new MusicPropertiesWithPath()
{
DefinedProperties = properties,
FileName = file.Path.Substring(file.Path.IndexOf("Music")).Remove(0, 6)
});
}
}
catch (Exception ex)
{
}
}
return(songs);
}
public async Task Initialize(ICamera camera, IStorage storage)
{
this.camera = camera;
this.storage = storage;
var cacheFolder = KnownFolders.PicturesLibrary;
this.dropFolder = await cacheFolder.GetFolderAsync("securitysystem-cameradrop");
this.dropFolderWatcher = dropFolder.CreateFileQuery();
var images = await this.dropFolderWatcher.GetFilesAsync();
var orderedImages = images.OrderByDescending(x => x.DateCreated);
this.newestImage = orderedImages.FirstOrDefault();
this.dropFolderWatcher.ContentsChanged += DropFolderWatcher_ContentsChanged;
this.allJoynBusAttachment = new AllJoynBusAttachment();
this.producer = new SecuritySystemProducer(this.allJoynBusAttachment);
this.allJoynBusAttachment.AboutData.DefaultAppName = Package.Current.DisplayName;
this.allJoynBusAttachment.AboutData.DefaultDescription = Package.Current.Description;
this.allJoynBusAttachment.AboutData.DefaultManufacturer = Package.Current.Id.Publisher;
this.allJoynBusAttachment.AboutData.SoftwareVersion = Package.Current.Id.Version.ToString();
this.allJoynBusAttachment.AboutData.IsEnabled = true;
this.producer.Service = this;
this.producer.Start();
}
private async Task <long> GetFolderSizeAsync()
{
var getFileSizeTasks = from file
in await folder.CreateFileQuery().GetFilesAsync()
select file.GetBasicPropertiesAsync().AsTask();
var fileSizes = await Task.WhenAll(getFileSizeTasks);
return(fileSizes.Sum(i => (long)i.Size));
}
/// <summary>
/// Calculates the size of the "Logs" folder.
/// </summary>
/// <returns>Returns the "Logs" folder size in KB.</returns>
public static async Task <long> getLogFolderSizeAsync()
{
StorageFolder logsFolder = await getLogFolderAsync();
StorageFileQueryResult result = logsFolder.CreateFileQuery();
var fileSizeTasks = (await result.GetFilesAsync()).Select(async file => (await file.GetBasicPropertiesAsync()).Size);
var sizes = await Task.WhenAll(fileSizeTasks);
return(sizes.Sum(l => (long)l) / 1024);
}
//--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\
#region --Set-, Get- Methods--
/// <summary>
/// Calculates the size of the "cachedImages" folder.
/// </summary>
/// <returns>Returns the "cachedImages" folder size in KB.</returns>
public async Task <long> getCachedImagesFolderSizeAsync()
{
StorageFolder f = await getCachedImagesFolderAsync();
StorageFileQueryResult result = f.CreateFileQuery(CommonFileQuery.OrderByName);
var fileSizeTasks = (await result.GetFilesAsync()).Select(async file => (await file.GetBasicPropertiesAsync()).Size);
var sizes = await Task.WhenAll(fileSizeTasks);
return(sizes.Sum(l => (long)l) / 1024);
}
public static async Task GetWallpaperStorageFile(StorageFolder folder, string name)
{
var query = folder.CreateFileQuery();
var files = await query.GetFilesAsync();
foreach (StorageFile file in files)
{
var fileName = file.Name.ToString();
if (fileName.Contains(name))
{
await ApplyImagetoWallpaperAsync(file);
}
}
}
public async Task <IEnumerable <MenuCard> > ReadMenuCardsAsync()
{
List <MenuCard> menuCards = new List <MenuCard>();
StorageFolder folder = ApplicationData.Current.RoamingFolder;
StorageFileQueryResult result = folder.CreateFileQuery();
var queryOptions = new QueryOptions();
queryOptions.IndexerOption = IndexerOption.DoNotUseIndexer;
queryOptions.FolderDepth = FolderDepth.Shallow;
queryOptions.FileTypeFilter.Add(".xml");
result.ApplyNewQueryOptions(queryOptions);
IReadOnlyList <StorageFile> files = await result.GetFilesAsync();
foreach (var file in files)
{
using (Stream stream = await file.OpenStreamForReadAsync())
{
try
{
var serializer = new DataContractSerializer(typeof(MenuCardData));
object data = await Task <object> .Run(() => serializer.ReadObject(stream));
//var serializer = new XmlSerializer(typeof(MenuCardData));
//object data = await Task<object>.Run(() => serializer.Deserialize(stream));
MenuCard menuCard = (data as MenuCardData).ToMenuCard();
menuCard.RestoreReferences();
menuCards.Add(menuCard);
}
catch (Exception)
{
// TODO: log exception
}
}
}
// read images
MenuCardImageStorage imageStorage = new MenuCardImageStorage();
foreach (var menuCard in menuCards)
{
if (menuCard.ImagePath != null)
{
menuCard.Image = await imageStorage.ReadImageAsync(menuCard.ImagePath);
}
}
return(menuCards);
}
//https://docs.microsoft.com/en-us/uwp/api/windows.storage.storagefolder
//https://stackoverflow.com/questions/45866872/get-all-files-inside-a-specific-folder-in-a-library-with-uwp
//Péter Bozsó
private async void BuildVideoList()
{
videoList.Items.Clear();
this.playButton.IsEnabled = false;
StorageFolder storageFolder = await currentFolder.GetFolderAsync(playList.SelectedItem.ToString());
StorageFileQueryResult results = storageFolder.CreateFileQuery();
IReadOnlyList <StorageFile> filesInFolder = await results.GetFilesAsync();
foreach (StorageFile item in filesInFolder)
{
string name = item.Name;
name = name.Substring(0, name.Length - 4);
videoList.Items.Add(name);
}
}
/// <summary>
/// Get a list of names of files whose filename ends with the specified extension
/// </summary>
/// <param name="storageFolder">Folder to be searched</param>
/// <param name="extension">File extension (e.g. .txt)</param>
/// <returns>List of names of files in the specified folder which end with the specified extension</returns>
public static async Task <List <string> > GetDocumentFilesOfTypeFromFolder(StorageFolder storageFolder, string extension)
{
var results = new List <string>();
try
{
var queryResult = storageFolder.CreateFileQuery();
var files = await queryResult.GetFilesAsync();
results.AddRange(from file in files where file.Name.ToLower().EndsWith(extension.ToLower()) select file.Name);
}
catch (Exception)
{
results = null;
}
return(results);
}
private static async Task <IList <IStorageFile> > GetAllFilesAsync(this StorageFolder folder, QueryOptions options = null, List <IStorageFile> files = null)
{
files = files ?? new List <IStorageFile>();
var subFolders = await folder.GetFoldersAsync();
foreach (var subfolder in subFolders)
{
await GetAllFilesAsync(subfolder, options, files);
}
var query = options == null?folder.CreateFileQuery() : folder.CreateFileQueryWithOptions(options);
var folderFiles = await query.GetFilesAsync();
files.AddRange(folderFiles);
return(files);
}
private async void GetFilesButton_Click(object sender, RoutedEventArgs e)
{
// Reset output.
OutputPanel.Children.Clear();
// Ask the user to pick a folder.
FolderPicker picker = new FolderPicker();
picker.FileTypeFilter.Add("*");
picker.ViewMode = PickerViewMode.List;
picker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
StorageFolder folder = await picker.PickSingleFolderAsync();
if (folder != null)
{
// Query the folder.
var query = folder.CreateFileQuery();
var fileList = await query.GetFilesAsync();
// Display file list with storage provider and availability.
foreach (StorageFile file in fileList)
{
// Create an entry in the list for the item.
var line = file.Name;
// Show the item's provider (This PC, SkyDrive, Network, or Application Content).
line += ": On " + file.Provider.DisplayName;
// Show if the item is available (SkyDrive items are usually available when
// online or when they are marked for "always available offline").
line += " (";
if (file.IsAvailable)
{
line += "available";
}
else
{
line += "not available";
}
line += ")";
OutputPanel.Children.Add(CreateLineItemTextBlock(line));
}
}
}
public static async Task <int> CalculateSize(this StorageFolder folder)
{
// Query all files in the folder. Make sure to add the CommonFileQuery
// So that it goes through all sub-folders as well
var folders = folder.CreateFileQuery(CommonFileQuery.OrderByName);
// Await the query, then for each file create a new Task which gets the size
var fileSizeTasks = (await folders.GetFilesAsync()).Select(async file => (await file.GetBasicPropertiesAsync()).Size);
// Wait for all of these tasks to complete. WhenAll thankfully returns each result
// as a whole list
var sizes = await Task.WhenAll(fileSizeTasks);
// Sum all of them up. You have to convert it to a long because Sum does not accept ulong.
long size = sizes.Sum(l => (long)l);
double d = (Convert.ToDouble(size) / 1024) / 1024;
return(Convert.ToInt32(d));
}
///////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Get the names of all the files in the default folder for this app
/// </summary>
/// <returns>List of all the files in this app's root folder</returns>
///////////////////////////////////////////////////////////////////////////////////
public static async Task <List <string> > GetDocumentFiles()
{
List <string> results = new List <string>();
try
{
StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
StorageFileQueryResult queryResult = storageFolder.CreateFileQuery();
var files = await queryResult.GetFilesAsync();
foreach (StorageFile file in files)
{
results.Add(file.Name);
}
}
catch (Exception ex)
{
results = null;
}
return(results);
}
private async Task <bool> checkIfToDoTasksFileIsPresent()
{
bool fileExists = false;
var query = localFolder.CreateFileQuery();
var listOfFiles = await query.GetFilesAsync();
if (listOfFiles.Count > 0)
{
foreach (var file in listOfFiles)
{
if (file.Name == "ToDoTasks.txt")
{
fileExists = true;
break;
}
}
}
return(fileExists);
}
///////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Get a list of names of files whose filename ends with the specified extension
/// </summary>
/// <param name="storageFolder">Folder to be searched</param>
/// <param name="extension">File extension (e.g. .txt)</param>
/// <returns>List of names of files in the specified folder which end with the specified extension</returns>
///////////////////////////////////////////////////////////////////////////////////
public static async Task <List <string> > GetDocumentFilesOfTypeFromFolder(StorageFolder storageFolder, string extension)
{
List <string> results = new List <string>();
try
{
StorageFileQueryResult queryResult = storageFolder.CreateFileQuery();
var files = await queryResult.GetFilesAsync();
foreach (StorageFile file in files)
{
if (file.Name.ToLower().EndsWith(extension.ToLower()))
{
results.Add(file.Name);
}
}
}
catch (Exception ex)
{
results = null;
}
return(results);
}
private async void playList_ItemClick(object sender, ItemClickEventArgs e)
{
videoList.Items.Clear();
this.playButton.IsEnabled = false;
try
{
StorageFolder storageFolder = await currentFolder.GetFolderAsync(e.ClickedItem.ToString());
StorageFileQueryResult results = storageFolder.CreateFileQuery();
IReadOnlyList <StorageFile> filesInFolder = await results.GetFilesAsync();
foreach (StorageFile item in filesInFolder)
{
string name = item.Name;
name = name.Substring(0, name.Length - 4);
videoList.Items.Add(name);
}
}
catch (Exception exception)
{
BuildPlaylists();
}
}
private static async Task <IReadOnlyList <StorageFile> > GetMediaFromFolder(StorageFolder folder,
CommonFileQuery query)
{
IReadOnlyList <StorageFile> files = null;
StorageFileQueryResult fileQuery;
var queryOptions = new QueryOptions(query,
new List <string>
{
".3g2",
".3gp",
".3gp2",
".3gpp",
".amv",
".asf",
".avi",
".divx",
".drc",
".dv",
".f4v",
".flv",
".gvi",
".gxf",
".ismv",
".iso",
".m1v",
".m2v",
".m2t",
".m2ts",
".m3u8",
".mkv",
".mov",
".mp2",
".mp2v",
".mp4",
".mp4v",
".mpe",
".mpeg",
".mpeg1",
".mpeg2",
".mpeg4",
".mpg",
".mpv2",
".mts",
".mtv",
".mxf",
".mxg",
".nsv",
".nut",
".nuv",
".ogm",
".ogv",
".ogx",
".ps",
".rec",
".rm",
".rmvb",
".tob",
".ts",
".tts",
".vob",
".vro",
".webm",
".wm",
".wmv",
".wtv",
".xesc",
});
try
{
fileQuery = folder.CreateFileQueryWithOptions(queryOptions);
files = await fileQuery.GetFilesAsync();
}
catch (Exception ex)
{
Debug.WriteLine("exception listing files");
Debug.WriteLine(ex.ToString());
}
// DLNA folders don't support advanced file listings, us a basic file query
if (files == null)
{
fileQuery = folder.CreateFileQuery(CommonFileQuery.OrderByName);
files = await fileQuery.GetFilesAsync();
}
return(files);
}
private async Task CalcFolderSizeAsync(string path)
{
if (!(calcSizeCancelToken is null))
{
calcSizeCancelToken.Cancel();
}
calcSizeCancelToken = new CancellationTokenSource();
if (!(calcSizeTask is null))
{
await calcSizeTask;
}
Text = "Calculating size...";
long size = 0;
calcSizeTask = Task.Run(async() =>
{
try
{
StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(path);
if (!(folder is null))
{
StorageFileQueryResult result = folder.CreateFileQuery(CommonFileQuery.OrderByName);
var fileSizeTasks = (await result.GetFilesAsync()).Select(async file => (await file.GetBasicPropertiesAsync()).Size);
var fileSizes = await Task.WhenAll(fileSizeTasks);
// Sum up and convert to kilo byte:
size = fileSizes.Sum(l => (long)l) / 1024;
}
}
catch (FileNotFoundException e)
{
Logger.Error("Failed to calculate folder size for path: " + path, e);
Text = "Invalid path!";
}
catch (Exception e)
{
Logger.Error("Failed to calculate folder size for path: " + path, e);
}
}, calcSizeCancelToken.Token);
await calcSizeTask;
if (calcSizeCancelToken is null || calcSizeCancelToken.IsCancellationRequested)
{
return;
}
StringBuilder sb = new StringBuilder("~ ");
if (size >= 1024)
{
sb.Append(size / 1024);
sb.Append(" MB");
}
else
{
sb.Append(size);
sb.Append(" KB");
}
Text = sb.ToString();
}
