private async void QueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
if (!isLibraryLoading)
{
await PerformWatcherWorkAsync(sender.Folder).ConfigureAwait(false);
}
}
private async void Query_ContentsChanged(IStorageQueryResultBase sender, object args)
{
try
{
var configFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appdata:///local/settings/terminal.json"));
var content = await FileIO.ReadTextAsync(configFile);
if (configContent != content)
{
configContent = content;
}
else
{
return;
}
await LoadAsync();
await GetInstalledTerminalsAsync();
ModelChanged?.Invoke(this);
}
catch
{
// ignored
}
}
private void QueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
if (!dispatcher.HasThreadAccess)
{
var t = dispatcher.RunAsync(CoreDispatcherPriority.Normal, ResetCollection);
}
}
private async void Query_ContentsChanged(IStorageQueryResultBase sender, object args)
{
try
{
var configFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appdata:///local/settings/PinnedItems.json"));
var content = await FileIO.ReadTextAsync(configFile);
if (configContent != content)
{
configContent = content;
}
else
{
return;
}
// Watched file changed externally, reload the sidebar items
await ReloadAsync();
}
catch
{
// ignored
}
}
private async void QueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
StorageItemsUpdated.Invoke(
MusicLibrary.ChangeTracker,
new StorageItemsUpdatedEventArgs(
await MusicLibrary.ChangeTracker.GetChangeReader().ReadBatchAsync()));
}
private void QueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
//if (MusicLibrary != null)
// StorageItemsUpdated.Invoke(
// MusicLibrary.ChangeTracker,
// new StorageItemsUpdatedEventArgs(
// await MusicLibrary.ChangeTracker.GetChangeReader().ReadBatchAsync()));
}
private async void OnContentsChanged(IStorageQueryResultBase sender, object args)
{
await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
_startIndex = 0;
Clear();
});
}
private async void DropFolderWatcher_ContentsChanged(IStorageQueryResultBase sender, object args)
{
var images = await this.dropFolder.GetFilesAsync();
var orderedImages = images.OrderByDescending(x => x.DateCreated);
var file = orderedImages.FirstOrDefault();
if (null != file && file.Name != this.newestImage.Name)
{
this.newestImage = file;
this.producer.EmitLastCaptureFileNameChanged();
this.producer.EmitLastCaptureTimeChanged();
}
}
// Handler for when the filesystem notifies us of a change to the file list
private void QueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
// This callback can occur on a different thread so we need to marshal it back to the UI thread
if (!_dispatcher.HasThreadAccess)
{
var t = _dispatcher.RunAsync(CoreDispatcherPriority.Normal, ResetCollection);
}
else
{
ResetCollection();
}
}
// Handler for when the filesystem notifies us of a change to the file list
private void QueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
// This callback can occur on a different thread so we need to marshal it back to the UI thread
if (!_dispatcher.HasThreadAccess)
{
var t = _dispatcher.RunAsync(CoreDispatcherPriority.Normal, ResetCollection);
}
else
{
ResetCollection();
}
}
private async void Query_ContentsChanged(IStorageQueryResultBase sender, object args)
{
// Run on UI thread.
await App.Current.NavigationService.Frame.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
var tracker = _folder.TryGetChangeTracker();
if (tracker != null)
{
var changeReader = tracker.GetChangeReader();
var changes = await changeReader.ReadBatchAsync();
foreach (var change in changes)
{
if (change.ChangeType == StorageLibraryChangeType.ChangeTrackingLost)
{
// Change tracker is in an invalid state and must be reset
// This should be a very rare case, but must be handled
tracker.Reset();
return;
}
if (change.IsOfType(StorageItemTypes.File))
{
// Process file change on UI thread.
await ProcessFileChange(change);
}
else if (change.IsOfType(StorageItemTypes.Folder))
{
// No-op; not interested in folders
}
else
{
if (change.ChangeType == StorageLibraryChangeType.Deleted)
{
// TODO: The application does not have to support FAT drives at the moment. NTFS is enough.
//UnknownItemRemoved(change.Path);
}
}
}
// If any changes were recorded, save database.
if (changes.Count > 0)
{
// Log query contens changed saving.
GalleryLog.QueryContentsChangedSaving();
await DatabaseUtils.SaveAllMetadatasAsync(MediaDatas);
}
await changeReader.AcceptChangesAsync();
}
});
}
private async void Query_ContentsChanged(IStorageQueryResultBase sender, object args)
{
if (suppressChangeEvent)
{
suppressChangeEvent = false;
return;
}
// watched file changed externally, reload the sidebar items
await CoreApplication.MainView.DispatcherQueue.EnqueueAsync(async() =>
{
await ReloadAsync();
});
}
private async void DropFolderWatcher_ContentsChanged(IStorageQueryResultBase sender, object args)
{
var images = await this.dropFolder.GetFilesAsync();
var orderedImages = images.OrderByDescending(x => x.DateCreated);
var file = orderedImages.FirstOrDefault();
if (null != file && file.Name != this.newestImage.Name)
{
this.newestImage = file;
this.producer.EmitLastCaptureFileNameChanged();
this.producer.EmitLastCaptureTimeChanged();
}
}
private void Query_ContentsChanged(IStorageQueryResultBase sender, object args)
{
var newGpioValues = dictionaryComparer.GetFilesRecursively(localFolder.Path) as Dictionary <string, string>;
var differences = dictionaryComparer.GetFileDifferences(oldGpioValues, newGpioValues);
oldGpioValues = newGpioValues;
foreach (var filePath in differences)
{
var pin = GetPin(filePath);
UpdatePins(pin, filePath);
}
}
//Event Handler for the folder listener
private async void resultSet_ContentsChanged(IStorageQueryResultBase sender, object args)
{
await driverList.ViewModel.LoadAsync();
//CoreDispatcher for running in UI thread
//Properties touching the UI should be updated with the UI thread
await _coreDispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ViewModel.IsLoading = false;
driverList.Visibility = Visibility.Visible;
updateStack.Visibility = Visibility.Visible;
loadingText.Visibility = Visibility.Collapsed;
});
}
/// Event Handlers
void OnContentsChanged(IStorageQueryResultBase sender, object args)
{
if (_isScanQueued)
{
ReportLine($"#### ContentsChanged Detected, but a scan is already queued\n");
return;
}
if (_cancellationToken != null && _cancellationToken.IsCancellationRequested)
{
ReportLine($"#### ContentsChanged Detected, but the job has been cancelled\n");
return;
}
_isScanQueued = true;
ReportLine($"#### Queueing another scan\n");
_ = Scan();
}
private async void ItemQuery_ContentsChanged(IStorageQueryResultBase sender, object args)
{
if (refreshRunning)
{
return;
}
refreshRunning = true;
//itemQuery.ApplyNewQueryOptions(new QueryOptions());
var items = await fileQuery.GetFilesAsync();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
await AddDifference(items, browseCts.Token);
});
refreshRunning = false;
}
private async void Query_ContentsChanged(IStorageQueryResultBase sender, object args)
{
if (suppressChangeEvent)
{
suppressChangeEvent = false;
return;
}
try
{
var configFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appdata:///local/settings/terminal.json"));
var content = await FileIO.ReadTextAsync(configFile);
if (configContent != content)
{
configContent = content;
}
else
{
return;
}
await LoadAsync();
await GetInstalledTerminalsAsync();
CoreApplication.MainView.DispatcherQueue.TryEnqueue(() =>
{
ModelChanged?.Invoke(this);
});
}
catch
{
// ignored
}
}
private void QueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
sensors?.PollSensors();
}
private async void FileContentsChanged(IStorageQueryResultBase sender, object args)
{
if (_filesRefreshing)
{
Debug.WriteLine("Filesystem change event fired but refresh is already running");
return;
}
else
{
Debug.WriteLine("Filesystem change event fired. Refreshing...");
}
_filesRefreshing = true;
//query options have to be reapplied otherwise old results are returned
_fileQueryResult.ApplyNewQueryOptions(_options);
_folderQueryResult.ApplyNewQueryOptions(_options);
var fileCount = await _fileQueryResult.GetItemCountAsync();
var folderCount = await _folderQueryResult.GetItemCountAsync();
var files = await _fileQueryResult.GetFilesAsync();
var folders = await _folderQueryResult.GetFoldersAsync();
var cancellationTokenSourceCopy = _cancellationTokenSource;
// modifying a file also results in a new unique FolderRelativeId so no need to check for DateModified explicitly
var addedFiles = files.Select(f => f.FolderRelativeId).Except(_filesAndFolders.Select(f => f.FolderRelativeId));
var addedFolders = folders.Select(f => f.FolderRelativeId).Except(_filesAndFolders.Select(f => f.FolderRelativeId));
var removedFilesAndFolders = _filesAndFolders
.Select(f => f.FolderRelativeId)
.Except(files.Select(f => f.FolderRelativeId))
.Except(folders.Select(f => f.FolderRelativeId))
.ToArray();
foreach (var file in addedFiles)
{
var toAdd = files.First(f => f.FolderRelativeId == file);
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() =>
{
await AddFile(toAdd, _pageName, cancellationTokenSourceCopy.Token);
});
}
foreach (var folder in addedFolders)
{
var toAdd = folders.First(f => f.FolderRelativeId == folder);
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() =>
{
await AddFolder(toAdd, _pageName, cancellationTokenSourceCopy.Token);
});
}
foreach (var item in removedFilesAndFolders)
{
var toRemove = _filesAndFolders.First(f => f.FolderRelativeId == item);
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
RemoveFileOrFolder(toRemove);
});
}
_filesRefreshing = false;
Debug.WriteLine("Filesystem refresh complete");
}
public IStorageQueryResultBaseEvents(IStorageQueryResultBase This)
{
this.This = This;
}
private void _fileQueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
Refresh();
}
private void Query_ContentsChanged(IStorageQueryResultBase sender, object args)
{
InvokeOnUIThread(() => RefreshUI());
}
private void Query_ContentsChanged(IStorageQueryResultBase sender, object args)
{
FilesChanged?.Invoke(sender, EventArgs.Empty);
}
private async static void QueryResult_ContentsChanged(IStorageQueryResultBase sender, object args)
{
await SettingsViewModel.PerformWatcherWorkAsync(sender.Folder).ConfigureAwait(false);
}
private void QueryOnContentsChanged(IStorageQueryResultBase sender, object args)
{
UpdateItems().FireAndForget();
}
