private async void GetAllVideos(StorageFolder KnownFolders, QueryOptions QueryOptions)
{
StorageFileQueryResult query = KnownFolders.CreateFileQueryWithOptions(QueryOptions);
IReadOnlyList<StorageFile> folderList = await query.GetFilesAsync();
// Get all the videos in the folder past in parameter
int id = 0;
foreach (StorageFile file in folderList)
{
using (StorageItemThumbnail thumbnail = await file.GetThumbnailAsync(ThumbnailMode.VideosView, 200, ThumbnailOptions.UseCurrentScale))
{
// Get video's properties
VideoProperties videoProperties = await file.Properties.GetVideoPropertiesAsync();
BitmapImage VideoCover = new BitmapImage();
VideoCover.SetSource(thumbnail);
Video video = new Video();
video.Id = id;
video.Name = file.Name;
video.DateCreated = file.DateCreated.UtcDateTime;
video.FileType = file.FileType;
video.VideoPath = file.Path;
video.Duration = videoProperties.Duration;
video.VideoFile = file;
video.VideoCover = VideoCover;
// Add the video to the ObservableCollection
Videos.Add(video);
id++;
}
}
}
sealed protected override async Task DoCleanup(Regex pattern, DateTime threshold)
{
var toDelete = new List<StorageFile>();
foreach (var file in await _logFolder.GetFilesAsync())
{
if (pattern.Match(file.Name).Success && file.DateCreated <= threshold)
toDelete.Add(file);
}
var qo = new QueryOptions(CommonFileQuery.DefaultQuery, new[] { ".zip" })
{
FolderDepth = FolderDepth.Shallow,
UserSearchFilter = "System.FileName:~<\"Log -\""
};
var query = ApplicationData.Current.TemporaryFolder.CreateFileQueryWithOptions(qo);
var oldLogs = await query.GetFilesAsync();
toDelete.AddRange(oldLogs);
// walk...
foreach (var file in toDelete)
{
try
{
await file.DeleteAsync();
}
catch (Exception ex)
{
InternalLogger.Current.Warn(string.Format("Failed to delete '{0}'.", file.Path), ex);
}
}
}
public async void DeleteExpiredPictures(string camera)
{
//Delete older images
try
{
var querySubfolders = new QueryOptions();
querySubfolders.FolderDepth = FolderDepth.Deep;
var cacheFolder = KnownFolders.PicturesLibrary;
cacheFolder = await cacheFolder.GetFolderAsync(AppSettings.FolderName);
var result = cacheFolder.CreateFileQueryWithOptions(querySubfolders);
var files = await result.GetFilesAsync();
foreach (StorageFile file in files)
{
//Caluclate oldest time in ticks using the user selected storage duration
long oldestTime = DateTime.UtcNow.Ticks - TimeSpan.FromDays(App.Controller.XmlSettings.StorageDuration).Ticks;
long picCreated = file.DateCreated.Ticks;
if (picCreated < oldestTime)
{
await file.DeleteAsync();
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in deleteExpiredPictures() " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "LocalStorage", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("FailedToDeletePicture", events);
}
}
private async void Find_Click(object sender, RoutedEventArgs e)
{
ContentTextOutput.Text = "";
List<string> propertyNames = new List<string>();
propertyNames.Add("System.FileName");
var queryOptions = new Windows.Storage.Search.QueryOptions();
queryOptions.IndexerOption = Windows.Storage.Search.IndexerOption.OnlyUseIndexer;
queryOptions.UserSearchFilter = FindQueryText.Text;
queryOptions.SetPropertyPrefetch(Windows.Storage.FileProperties.PropertyPrefetchOptions.DocumentProperties, propertyNames);
// Query the Pictures library.
StorageFileQueryResult queryResult = Windows.Storage.KnownFolders.PicturesLibrary.CreateFileQueryWithOptions(queryOptions);
IReadOnlyList<StorageFile> files = await queryResult.GetFilesAsync();
foreach (StorageFile file in files)
{
IDictionary<String, IReadOnlyList<Windows.Data.Text.TextSegment>> fileRangeProperties = queryResult.GetMatchingPropertiesWithRanges(file);
if (fileRangeProperties.ContainsKey("System.FileName"))
{
IReadOnlyList<Windows.Data.Text.TextSegment> ranges;
fileRangeProperties.TryGetValue("System.FileName", out ranges);
rootPage.HighlightRanges(ContentTextOutput, file.DisplayName, ranges);
}
// Note: You can continue looking for other properties you would like to highlight on the file here.
}
if (files.Count == 0)
{
ContentTextOutput.Text = "There were no matching files in your Pictures Library";
}
}
public virtual Assembly[] GetAssemblies()
{
var options = new QueryOptions { FileTypeFilter = { ".exe", ".dll" } };
StorageFileQueryResult query = Package.Current.InstalledLocation.CreateFileQueryWithOptions(options);
IReadOnlyList<StorageFile> files = query.GetFilesAsync().AsTask().Result;
var assemblies = new List<Assembly>(files.Count);
for (var i = 0; i < files.Count; i++)
{
StorageFile file = files[i];
try
{
Assembly assembly = Assembly.Load(new AssemblyName { Name = Path.GetFileNameWithoutExtension(file.Name) });
assemblies.Add(assembly);
}
catch (IOException)
{
}
catch (BadImageFormatException)
{
}
}
Assembly thisAssembly = GetType().GetTypeInfo().Assembly;
// this happens with .NET Native
if (!assemblies.Contains(thisAssembly))
assemblies.Add(thisAssembly);
return assemblies.ToArray();
}
private async Task <List <StorageFile> > CreateFileListAsync()
{
List <StorageFile> files = new List <StorageFile>();
if (string.IsNullOrWhiteSpace(_state.CurrentPackage.Name))
{
return(files);
}
StorageFolder pictureFolder = await KnownFolders.PicturesLibrary.CreateFolderAsync("SmartInk", CreationCollisionOption.OpenIfExists);
var projectFolder = await pictureFolder.CreateFolderAsync(_state.CurrentPackage.Name, CreationCollisionOption.OpenIfExists);
//await SetupWatcher(projectFolder);
List <string> fileTypeFilter = new List <string>();
fileTypeFilter.Add(".jpg");
fileTypeFilter.Add(".jpeg");
fileTypeFilter.Add(".png");
var options = new Windows.Storage.Search.QueryOptions(Windows.Storage.Search.CommonFileQuery.OrderByName, fileTypeFilter);
var folders = await projectFolder.GetFoldersAsync();
TotalImageCount = 0;
foreach (var folder in folders)
{
var images = await folder.GetFilesAsync();
TotalImageCount += images.Count;
files.AddRange(images);
}
return(files);
}
private async void Find_Click(object sender, RoutedEventArgs e)
{
ContentTextOutput.Text = "";
List <string> propertyNames = new List <string>();
propertyNames.Add("System.FileName");
var queryOptions = new Windows.Storage.Search.QueryOptions();
queryOptions.IndexerOption = Windows.Storage.Search.IndexerOption.OnlyUseIndexer;
queryOptions.UserSearchFilter = FindQueryText.Text;
queryOptions.SetPropertyPrefetch(Windows.Storage.FileProperties.PropertyPrefetchOptions.DocumentProperties, propertyNames);
// Query the Pictures library.
StorageFileQueryResult queryResult = Windows.Storage.KnownFolders.PicturesLibrary.CreateFileQueryWithOptions(queryOptions);
IReadOnlyList <StorageFile> files = await queryResult.GetFilesAsync();
foreach (StorageFile file in files)
{
IDictionary <String, IReadOnlyList <Windows.Data.Text.TextSegment> > fileRangeProperties = queryResult.GetMatchingPropertiesWithRanges(file);
if (fileRangeProperties.ContainsKey("System.FileName"))
{
IReadOnlyList <Windows.Data.Text.TextSegment> ranges;
fileRangeProperties.TryGetValue("System.FileName", out ranges);
rootPage.HighlightRanges(ContentTextOutput, file.DisplayName, ranges);
}
// Note: You can continue looking for other properties you would like to highlight on the file here.
}
if (files.Count == 0)
{
ContentTextOutput.Text = "There were no matching files in your Pictures Library";
}
}
private async Task <bool> MonitorConfigFile()
{
bool retVal = true;
try
{
// Watch for all ".xml" files (there is only the config.xml file in this app's data folder)
// And add a handler for when the folder contents change
var fileTypeQuery = new List <string>();
fileTypeQuery.Add(".xml");
var options = new Windows.Storage.Search.QueryOptions(Windows.Storage.Search.CommonFileQuery.DefaultQuery, fileTypeQuery);
_query = ApplicationData.Current.LocalFolder.CreateFileQueryWithOptions(options);
_query.ContentsChanged += FolderContentsChanged;
// Start Monitoring. The first time this is called (after starting the query) we want to ignore the notification
_bIgnoreFirstChangeNotification = true;
var files = await _query.GetFilesAsync();
}
catch (Exception /*ex*/)
{
retVal = false;
}
return(retVal);
}
public async static Task<bool> Validate(IXamlFilesData filesData)
{
var sha1 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
var sha1Hash = sha1.CreateHash();
var queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, new[] { ".xaml" }) {FolderDepth = FolderDepth.Deep};
var query = Package.Current.InstalledLocation.CreateFileQueryWithOptions(queryOptions);
var files = await query.GetFilesAsync();
foreach (var file in files)
{
string hash;
if (filesData.FilesToVerify.TryGetValue(file.Name, out hash))
{
var xaml = (await FileIO.ReadTextAsync(file)).Trim();
var buff = CryptographicBuffer.ConvertStringToBinary(xaml, BinaryStringEncoding.Utf16BE);
sha1Hash.Append(buff);
var newHash = CryptographicBuffer.EncodeToBase64String(sha1Hash.GetValueAndReset());
if (newHash != hash)
return false;
}
}
return true;
}
public StartupPage()
{
InitializeComponent();
//#if WINDOWS_APP
var temp = new QueryOptions();
//#endif
}
private async void GetFilesButton_Click(object sender, RoutedEventArgs e)
{
// Reset output.
OutputPanel.Children.Clear();
// Set up file type filter.
List<string> fileTypeFilter = new List<string>();
fileTypeFilter.Add(".jpg");
fileTypeFilter.Add(".png");
fileTypeFilter.Add(".bmp");
fileTypeFilter.Add(".gif");
// Create query options.
var queryOptions = new QueryOptions(CommonFileQuery.OrderByName, fileTypeFilter);
// Set up property prefetch - use the PropertyPrefetchOptions for top-level properties
// and a list for additional properties.
List<string> propertyNames = new List<string>();
propertyNames.Add(CopyrightProperty);
propertyNames.Add(ColorSpaceProperty);
queryOptions.SetPropertyPrefetch(PropertyPrefetchOptions.ImageProperties, propertyNames);
// Set up thumbnail prefetch if needed, e.g. when creating a picture gallery view.
/*
const uint requestedSize = 190;
const ThumbnailMode thumbnailMode = ThumbnailMode.PicturesView;
const ThumbnailOptions thumbnailOptions = ThumbnailOptions.UseCurrentScale;
queryOptions.SetThumbnailPrefetch(thumbnailMode, requestedSize, thumbnailOptions);
*/
// Set up the query and retrieve files.
StorageFolder picturesFolder = await KnownFolders.GetFolderForUserAsync(null /* current user */, KnownFolderId.PicturesLibrary);
var query = picturesFolder.CreateFileQueryWithOptions(queryOptions);
IReadOnlyList<StorageFile> fileList = await query.GetFilesAsync();
foreach (StorageFile file in fileList)
{
OutputPanel.Children.Add(CreateHeaderTextBlock(file.Name));
// GetImagePropertiesAsync will return synchronously when prefetching has been able to
// retrieve the properties in advance.
var properties = await file.Properties.GetImagePropertiesAsync();
OutputPanel.Children.Add(CreateLineItemTextBlock("Dimensions: " + properties.Width + "x" + properties.Height));
// Similarly, extra properties are retrieved asynchronously but may
// return immediately when prefetching has fulfilled its task.
IDictionary<string, object> extraProperties = await file.Properties.RetrievePropertiesAsync(propertyNames);
var propValue = extraProperties[CopyrightProperty];
OutputPanel.Children.Add(CreateLineItemTextBlock("Copyright: " + GetPropertyDisplayValue(propValue)));
propValue = extraProperties[ColorSpaceProperty];
OutputPanel.Children.Add(CreateLineItemTextBlock("Color space: " + GetPropertyDisplayValue(propValue)));
// Thumbnails can also be retrieved and used.
// var thumbnail = await file.GetThumbnailAsync(thumbnailMode, requestedSize, thumbnailOptions);
}
}
private void fileInitialisation()
{
var pictureQueryOptions = new QueryOptions();
// Don't read through all the subfolders.
pictureQueryOptions.FolderDepth = FolderDepth.Shallow;
// Apply the query on the PicturesLibrary
var pictureQuery = KnownFolders.PicturesLibrary.CreateFileQueryWithOptions(pictureQueryOptions);
// Get picture information
var picturesInformation = new FileInformationFactory(pictureQuery, ThumbnailMode.PicturesView);
picturesSource.Source = picturesInformation.GetVirtualizedFilesVector();
}
public async void UploadPictures(string camera)
{
if (isLoggedIn)
{
uploadPicturesMutexLock.WaitOne();
try
{
QueryOptions querySubfolders = new QueryOptions();
querySubfolders.FolderDepth = FolderDepth.Deep;
StorageFolder cacheFolder = KnownFolders.PicturesLibrary;
cacheFolder = await cacheFolder.GetFolderAsync(AppSettings.FolderName);
var result = cacheFolder.CreateFileQueryWithOptions(querySubfolders);
var files = await result.GetFilesAsync();
foreach (StorageFile file in files)
{
string imageName = string.Format(AppSettings.ImageNameFormat, camera, DateTime.Now.ToString("MM_dd_yyyy/HH"), DateTime.UtcNow.Ticks.ToString());
try
{
await uploadPictureToOneDrive(AppSettings.FolderName, imageName, file);
numberUploaded++;
// uploadPictureToOnedrive should throw an exception if it fails, so it's safe to delete
await file.DeleteAsync();
}
catch (Exception ex)
{
Debug.WriteLine("UploadPictures(): " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("FailedToUploadPicture", events);
}
this.lastUploadTime = DateTime.Now;
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in UploadPictures() " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("FailedToUploadPicture", events);
}
finally
{
uploadPicturesMutexLock.ReleaseMutex();
}
}
}
public async void UploadPictures()
{
if (oneDriveConnector.isLoggedIn)
{
// Stop timer to allow time for uploading pictures in case next timer tick overlaps with this ongoing one
AppController.uploadPicturesTimer.Stop();
try
{
QueryOptions querySubfolders = new QueryOptions();
querySubfolders.FolderDepth = FolderDepth.Deep;
StorageFolder cacheFolder = KnownFolders.PicturesLibrary;
cacheFolder = await cacheFolder.GetFolderAsync(AppSettings.FolderName);
var result = cacheFolder.CreateFileQueryWithOptions(querySubfolders);
var files = await result.GetFilesAsync();
foreach (StorageFile file in files)
{
try
{
await oneDriveConnector.UploadFileAsync(file, String.Format("{0}/{1}", App.Controller.XmlSettings.OneDriveFolderPath, DateTime.Now.ToString("yyyy_MM_dd")));
numberUploaded++;
// uploadPictureToOnedrive should throw an exception if it fails, so it's safe to delete
await file.DeleteAsync();
}
catch (Exception ex)
{
Debug.WriteLine("UploadPictures(): " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
TelemetryHelper.TrackEvent("FailedToUploadPicture", events);
}
this.lastUploadTime = DateTime.Now;
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in UploadPictures() " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
TelemetryHelper.TrackEvent("FailedToUploadPicture", events);
}
finally
{
AppController.uploadPicturesTimer.Start();
}
}
}
public async void UploadPictures()
{
if (oneDriveConnector.isLoggedIn)
{
// Stop timer to allow time for uploading pictures in case next timer tick overlaps with this ongoing one
AppController.uploadPicturesTimer.Stop();
try
{
QueryOptions querySubfolders = new QueryOptions();
querySubfolders.FolderDepth = FolderDepth.Deep;
StorageFolder cacheFolder = KnownFolders.PicturesLibrary;
cacheFolder = await cacheFolder.GetFolderAsync(AppSettings.FolderName);
var result = cacheFolder.CreateFileQueryWithOptions(querySubfolders);
var files = await result.GetFilesAsync(0, MaxPictureUpload);
foreach (StorageFile file in files)
{
try
{
await uploadWithRetry(file);
}
catch (Exception ex)
{
Debug.WriteLine("UploadPictures(): " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
events.Add("File Failure", "File name: " + file.Name);
TelemetryHelper.TrackEvent("FailedToUploadPicture", events);
TelemetryHelper.TrackException(ex);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in UploadPictures() " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "OneDrive", ex.Message } };
events.Add("Setup routine failure", "Exception thrown getting file list from pictures library");
TelemetryHelper.TrackEvent("FailedToUploadPicture", events);
TelemetryHelper.TrackException(ex);
}
finally
{
AppController.uploadPicturesTimer.Start();
}
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var queryOptions = new QueryOptions();
queryOptions.FolderDepth = FolderDepth.Deep;
queryOptions.IndexerOption = IndexerOption.UseIndexerWhenAvailable;
queryOptions.SortOrder.Clear();
var sortEntry = new SortEntry();
sortEntry.PropertyName = "System.FileName";
sortEntry.AscendingOrder = true;
queryOptions.SortOrder.Add(sortEntry);
var fileQuery = KnownFolders.PicturesLibrary.CreateFileQueryWithOptions(queryOptions);
const uint size = 190; // default size for PicturesView mode
var fileInformationFactory = new FileInformationFactory(fileQuery, ThumbnailMode.PicturesView, size, ThumbnailOptions.UseCurrentScale, true);
itemsViewSource.Source = fileInformationFactory.GetVirtualizedFilesVector();
}
private void VideoPanel_Loaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
// Acces to Videos libray
StorageFolder VideosLibrary = KnownFolders.VideosLibrary;
// Set up file type filter.
List<string> fileTypeFilter = new List<string>();
fileTypeFilter.Add(".avi");
fileTypeFilter.Add(".mkv");
fileTypeFilter.Add(".m4v");
// Get the options for selecting
QueryOptions QueryOption = new QueryOptions(CommonFileQuery.OrderByName, fileTypeFilter);
// Get folders and Pictures
GetFoldersAndVideos(VideosLibrary, QueryOption);
}
public static async void GetVideoList()
{
// Create file query for change detection
var options = new Windows.Storage.Search.QueryOptions
{
FolderDepth = Windows.Storage.Search.FolderDepth.Deep
};
// Add change detection event listener
queryResult = videoLibrary.CreateFileQueryWithOptions(options);
queryResult.ContentsChanged += QueryContentsChanged;
// Read videos
storedVideo = await queryResult.GetFilesAsync();
// // get tumbnails
UpdateThumbs();
}
/// <summary>
/// helper for all list by functions
/// </summary>
async Task GroupByHelperAsync(QueryOptions queryOptions)
{
OutputPanel.Children.Clear();
StorageFolder picturesFolder = KnownFolders.PicturesLibrary;
StorageFolderQueryResult queryResult = picturesFolder.CreateFolderQueryWithOptions(queryOptions);
IReadOnlyList<StorageFolder> folderList = await queryResult.GetFoldersAsync();
foreach (StorageFolder folder in folderList)
{
IReadOnlyList<StorageFile> fileList = await folder.GetFilesAsync();
OutputPanel.Children.Add(CreateHeaderTextBlock(folder.Name + " (" + fileList.Count + ")"));
foreach (StorageFile file in fileList)
{
OutputPanel.Children.Add(CreateLineItemTextBlock(file.Name));
}
}
}
public async void UploadPictures()
{
// Stop timer to allow time for uploading pictures in case next timer tick overlaps with this ongoing one
AppController.uploadPicturesTimer.Stop();
try
{
var querySubfolders = new QueryOptions();
querySubfolders.FolderDepth = FolderDepth.Deep;
var cacheFolder = KnownFolders.PicturesLibrary;
cacheFolder = await cacheFolder.GetFolderAsync("securitysystem-cameradrop");
var result = cacheFolder.CreateFileQueryWithOptions(querySubfolders);
var count = await result.GetItemCountAsync();
var files = await result.GetFilesAsync();
foreach (StorageFile file in files)
{
//Image name contains creation time
string imageName = string.Format(AppSettings.ImageNameFormat, DateTime.Now.ToString("yyyy_MM_dd/HH"), DateTime.UtcNow.Ticks.ToString());
if (file.IsAvailable)
{
//Upload image to blob storage
await uploadPictureToAzure(imageName, file);
//Delete image from local storage after a successful upload
await file.DeleteAsync();
}
}
this.lastUploadTime = DateTime.Now;
}
catch (Exception ex)
{
Debug.WriteLine("Exception in uploadPictures() " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "Azure", ex.Message } };
TelemetryHelper.TrackEvent("FailedToUploadPicture", events);
}
finally
{
AppController.uploadPicturesTimer.Start();
}
}
public async Task<IEnumerable<LibraryPhoto>> LoadFilesFromPictureLibraryAsync()
{
var queryOptions = new QueryOptions(CommonFileQuery.OrderByDate, new[] { ".jpg", ".gif", ".png" });
var query = KnownFolders.PicturesLibrary.CreateFileQueryWithOptions(queryOptions);
var files = await query.GetFilesAsync();
var photos = new List<LibraryPhoto>();
foreach (var file in files)
{
photos.Add(new LibraryPhoto
{
Title = file.DisplayName,
DateCreated = file.DateCreated.LocalDateTime,
Path = file.Path,
Thumbnail = await GetThumbnail(file)
});
}
return photos;
}
/*******************************************************************************************
* PUBLIC METHODS
*******************************************************************************************/
public async void UploadPictures(string camera)
{
uploadPicturesMutexLock.WaitOne();
try
{
var querySubfolders = new QueryOptions();
querySubfolders.FolderDepth = FolderDepth.Deep;
var cacheFolder = KnownFolders.PicturesLibrary;
cacheFolder = await cacheFolder.GetFolderAsync("securitysystem-cameradrop");
var result = cacheFolder.CreateFileQueryWithOptions(querySubfolders);
var count = await result.GetItemCountAsync();
var files = await result.GetFilesAsync();
foreach (StorageFile file in files)
{
//Image name contains creation time
string imageName = string.Format(AppSettings.ImageNameFormat, camera, DateTime.Now.ToString("MM_dd_yyyy/HH"), DateTime.UtcNow.Ticks.ToString());
if (file.IsAvailable)
{
//Upload image to blob storage
await uploadPictureToAzure(imageName, file);
//Delete image from local storage after a successful upload
await file.DeleteAsync();
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in uploadPictures() " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "Azure", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("FailedToUploadPicture", events);
}
finally
{
uploadPicturesMutexLock.ReleaseMutex();
}
}
private async void SearchButton_Click(object sender, RoutedEventArgs e)
{
StorageFolder musicFolder = await KnownFolders.GetFolderForUserAsync(null /* current user */, KnownFolderId.MusicLibrary);
List<string> fileTypeFilter = new List<string>();
fileTypeFilter.Add("*");
QueryOptions queryOptions = new QueryOptions(CommonFileQuery.OrderBySearchRank, fileTypeFilter);
//use the user's input to make a query
queryOptions.UserSearchFilter = InputTextBox.Text;
StorageFileQueryResult queryResult = musicFolder.CreateFileQueryWithOptions(queryOptions);
StringBuilder outputText = new StringBuilder();
//find all files that match the query
IReadOnlyList<StorageFile> files = await queryResult.GetFilesAsync();
//output how many files that match the query were found
if (files.Count == 0)
{
outputText.Append("No files found for '" + queryOptions.UserSearchFilter + "'");
}
else if (files.Count == 1)
{
outputText.Append(files.Count + " file found:\n\n");
}
else
{
outputText.Append(files.Count + " files found:\n\n");
}
//output the name of each file that matches the query
foreach (StorageFile file in files)
{
outputText.Append(file.Name + "\n");
}
OutputTextBlock.Text = outputText.ToString();
}
private async void LoadPhoto()
{
var queryOptions = new Windows.Storage.Search.QueryOptions(CommonFileQuery.OrderByDate, null);
queryOptions.SetThumbnailPrefetch(ThumbnailMode.PicturesView, 100,
ThumbnailOptions.ReturnOnlyIfCached);
//queryOptions.SetPropertyPrefetch(PropertyPrefetchOptions.ImageProperties, new string[] { "System.Size" });
queryOptions.SetThumbnailPrefetch(ThumbnailMode.ListView, 80, ThumbnailOptions.ReturnOnlyIfCached);
StorageFileQueryResult queryResults = KnownFolders.PicturesLibrary.CreateFileQueryWithOptions(queryOptions);
IReadOnlyList <StorageFile> files = await queryResults.GetFilesAsync();
foreach (var file in files)
{
var thumbnail = await file.GetThumbnailAsync(ThumbnailMode.ListView, 40, ThumbnailOptions.ReturnOnlyIfCached);
thumbnailList.Add(thumbnail);
debugText.Text = thumbnailList.Count.ToString();
//BitmapImage bm = new BitmapImage();
//bm.SetSource(thumbnail);
//photoList.Add(bm);
//ImageProperties imageProperties = await file.Properties.GetImagePropertiesAsync();
//// Do something with the date the image was taken.
//DateTimeOffset dateTaken = imageProperties.DateTaken;
//// Performance gains increase with the number of properties that are accessed.
//IDictionary<String, object> propertyResults =
// await file.Properties.RetrievePropertiesAsync(
// new string[] { "System.Size" });
//// Get/Set extra properties here
//var systemSize = propertyResults["System.Size"];
}
}
private async void GetFoldersAndVideos(StorageFolder VideosLibrary, QueryOptions QueryOption)
{
StartUpProgressRing.IsActive = true;
// Clear all the ObservableCollection
VideoFiles.Clear();
VideoFolder.Clear();
QueryOption.FolderDepth = FolderDepth.Shallow;
// Get Folders and Videos
Gf = new GetFolders(VideosLibrary);
Gv = new GetVideos(VideosLibrary, QueryOption);
await Task.Delay(500);
ObservableCollection<Folder> Folders = Gf.Folders;
ObservableCollection<Video> Videos = Gv.Videos;
// Pluck off meta data from pictures and folders
PopulateFoldersList(Folders);
PopulateVideoList(Videos);
StartUpProgressRing.IsActive = false;
}
public void ApplyNewQueryOptions(QueryOptions newQueryOptions) { }
/// <summary>
/// Finds and displays the first image file on the storage referenced by the device information element.
/// </summary>
/// <param name="deviceInfoElement">Contains information about a selected device.</param>
async private Task GetFirstImageFromStorageAsync(DeviceInformation deviceInfoElement)
{
// Convert the selected device information element to a StorageFolder
var storage = StorageDevice.FromId(deviceInfoElement.Id);
var storageName = deviceInfoElement.Name;
// Construct the query for image files
var queryOptions = new QueryOptions(CommonFileQuery.OrderByName, new List<string> { ".jpg", ".png", ".gif" });
var imageFileQuery = storage.CreateFileQueryWithOptions(queryOptions);
// Run the query for image files
rootPage.NotifyUser("Looking for images on " + storageName + " ...", NotifyType.StatusMessage);
var imageFiles = await imageFileQuery.GetFilesAsync();
if (imageFiles.Count > 0)
{
var imageFile = imageFiles[0];
rootPage.NotifyUser("Found " + imageFile.Name + " on " + storageName, NotifyType.StatusMessage);
await DisplayImageAsync(imageFile);
}
else
{
rootPage.NotifyUser("No images were found on " + storageName + ". You can use scenario 2 to transfer an image to it", NotifyType.StatusMessage);
}
}
public GetVideos(StorageFolder KnownFolders, QueryOptions QueryOptions)
{
Videos = new ObservableCollection<Video>();
GetAllVideos(KnownFolders, QueryOptions);
}
/// <summary>
/// This is the click handler for the button that represents a user.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async private void UserButton_Click(object sender, RoutedEventArgs e)
{
Button b = sender as Button;
if (b != null)
{
OutputProgressRing.IsActive = true;
// Get the folder that represents the user's files, which wwe saved as the DataContext.
StorageFolder folder = (StorageFolder)b.DataContext;
// This try/catch block is for scenarios where the HomeGroup Known Folder is not available.
try
{
// Search for all files in that folder.
QueryOptions queryOptions = new QueryOptions(CommonFileQuery.OrderBySearchRank, null);
queryOptions.UserSearchFilter = "*";
StorageFileQueryResult queryResults = folder.CreateFileQueryWithOptions(queryOptions);
IReadOnlyList<StorageFile> files = await queryResults.GetFilesAsync();
string outputString = string.Format("Files shared by {0}: {1}\n", folder.Name, files.Count);
foreach (StorageFile file in files)
{
outputString += file.Name + "\n";
}
rootPage.NotifyUser(outputString, NotifyType.StatusMessage);
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage);
}
OutputProgressRing.IsActive = false;
}
}
/// <summary>
/// Finds and displays the first image file on the storage.
/// </summary>
/// <param name="storage"></param>
async private Task GetFirstImageFromStorageAsync(StorageFolder storage)
{
var storageName = storage.Name;
// Construct the query for image files
var queryOptions = new QueryOptions(CommonFileQuery.OrderByName, new List<string> { ".jpg", ".png", ".gif" });
var imageFileQuery = storage.CreateFileQueryWithOptions(queryOptions);
// Run the query for image files
rootPage.NotifyUser("[Launched by Autoplay] Looking for images on " + storageName + " ...", NotifyType.StatusMessage);
var imageFiles = await imageFileQuery.GetFilesAsync();
if (imageFiles.Count > 0)
{
var imageFile = imageFiles[0];
rootPage.NotifyUser("[Launched by Autoplay] Found " + imageFile.Name + " on " + storageName, NotifyType.StatusMessage);
await DisplayImageAsync(imageFile);
}
else
{
rootPage.NotifyUser("[Launched by Autoplay] No images were found on " + storageName + ". You can use scenario 2 to transfer an image to it", NotifyType.StatusMessage);
}
}
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
var filter = new List<string> { ".pdf" };
var storageFolders = _sourceService.GetAllAsStorageFoldersAsync().Result;
foreach (var storageFolder in storageFolders)
{
var source = _sourceService.GetByUrl(storageFolder.Path);
var options = new QueryOptions(CommonFileQuery.OrderByName, filter);
var ss = storageFolder.CreateItemQueryWithOptions(options);
//Get all PDF files for storagefolder
var pdfFiles = ss.GetItemsAsync().GetAwaiter().GetResult();
for (var i = 0; i < pdfFiles.Count; i++)
{
var progress = Utils.CalculatePercentage(i, 0, pdfFiles.Count);
if (Worker.CancellationPending)
{
e.Cancel = true;
return;
}
var book = new Book
{
Title = Path.GetFileNameWithoutExtension(pdfFiles[i].Name),
Source = source,
FileName = Path.GetFileName(pdfFiles[i].Path),
FullPathAndFileName = pdfFiles[i].Path,
Rating = 0
};
var book1 = book;
var existingBook = _bookService.Exists(book1);
if (existingBook == false) // Add Book
{
var xml = storageFolder.TryGetItemAsync(book.Title + ".xml").GetAwaiter().GetResult();
if (xml != null)
{
book = XmlToBook(xml as StorageFile, book);
}
else
{
book = UseIsbn(pdfFiles[i] as StorageFile, book);
}
var cover = new Cover();
var coverPath = _pdfCover.GenerateCoverImage(book, 0, _sourcerepo, storageFolder, pdfFiles[i] as StorageFile).Result;
cover.FileName = Path.GetFileName(coverPath);
book.Cover = cover;
book = _bookService.Add(book);
Worker.ReportProgress(progress, book);
}
else
{
Tuple<Book, string> exists = new Tuple<Book, string>(book, "Exists");
Worker.ReportProgress(progress, exists);
}
}
}
}
async private void LoadMediaFiles()
{
try
{
StorageFolder mediaServerFolder = mediaServers[dmsSelect.SelectedIndex];
var queryOptions = new QueryOptions();
queryOptions.FolderDepth = FolderDepth.Deep;
queryOptions.UserSearchFilter = "System.Kind:=video";
if (mediaServerFolder.AreQueryOptionsSupported(queryOptions))
{
var queryFolder = mediaServerFolder.CreateFileQueryWithOptions(queryOptions);
mediaFiles = await queryFolder.GetFilesAsync(0, 25);
mediaSelect.Items.Clear();
if (mediaFiles.Count == 0)
{
rootPage.NotifyUser("No Media Files found ", NotifyType.StatusMessage);
}
else
{
foreach (StorageFile file in mediaFiles)
{
mediaSelect.Items.Add(file.DisplayName);
}
rootPage.NotifyUser("Media files retrieved", NotifyType.StatusMessage);
}
}
else
{
List<StorageFile> lstMediaItems = new List<StorageFile>();
var countOfVideoFilesFound = await BrowseForVideoFiles(mediaServerFolder, lstMediaItems, 25);
mediaFiles = lstMediaItems;
if (countOfVideoFilesFound > 0)
{
rootPage.NotifyUser("Media files retrieved", NotifyType.StatusMessage);
}
else
{
rootPage.NotifyUser("No Media Files found ", NotifyType.StatusMessage);
}
}
}
catch (Exception e)
{
rootPage.NotifyUser("Error locating media files " + e.Message, NotifyType.ErrorMessage);
}
}
private Task GroupByHelperAsync(QueryOptions queryOptions)
{
throw new NotImplementedException();
}
