public async Task LoadMorePropertyAsync() { if ((this is FileSystemStorageFile && SettingControl.ContentLoadMode == LoadMode.OnlyFile) || SettingControl.ContentLoadMode == LoadMode.FileAndFolder) { if (!CheckIfPropertyLoaded()) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async() => { try { await LoadMorePropertyCore(); OnPropertyChanged(nameof(Size)); OnPropertyChanged(nameof(Name)); OnPropertyChanged(nameof(ModifiedTime)); OnPropertyChanged(nameof(Thumbnail)); OnPropertyChanged(nameof(DisplayType)); } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw in {nameof(LoadMorePropertyAsync)}, StorageType: {GetType().FullName}, Path: {Path}"); } }); } } }
public async virtual Task <FileStream> GetFileStreamFromFileAsync(AccessMode Mode) { try { if (WIN_Native_API.CreateFileStreamFromExistingPath(Path, Mode) is FileStream Stream) { return(Stream); } else { if (await GetStorageItemAsync() is StorageFile File) { SafeFileHandle Handle = File.GetSafeFileHandle(); return(new FileStream(Handle, FileAccess.ReadWrite)); } else { return(null); } } } catch (Exception ex) { LogTracer.Log(ex, "Could not create a new file stream"); return(null); } }
/// <summary> /// 更新反馈对象的标题和建议内容 /// </summary> /// <param name="Title">标题</param> /// <param name="Suggestion">建议</param> /// <param name="Guid">唯一标识</param> /// <returns></returns> public async Task <bool> UpdateFeedBackAsync(string Title, string Suggestion, string Guid) { if (await MakeConnectionUseable().ConfigureAwait(false)) { try { using (MySqlCommand Command = new MySqlCommand("Update FeedBackTable Set Title=@NewTitle, Suggestion=@NewSuggestion Where GUID=@GUID", Connection)) { Command.Parameters.AddWithValue("@NewTitle", Title); Command.Parameters.AddWithValue("@NewSuggestion", Suggestion); Command.Parameters.AddWithValue("@GUID", Guid); await Command.ExecuteNonQueryAsync().ConfigureAwait(false); } return(true); } catch (Exception ex) { LogTracer.Log(ex, $"An error was threw in { nameof(UpdateFeedBackAsync)}"); return(false); } } else { return(false); } }
/// <summary> /// 删除反馈内容 /// </summary> /// <param name="Item">反馈对象</param> /// <returns></returns> public async Task <bool> DeleteFeedBackAsync(FeedBackItem Item) { if (Item != null) { if (await MakeConnectionUseable().ConfigureAwait(false)) { try { using (MySqlCommand Command = new MySqlCommand("Delete From FeedBackTable Where GUID=@GUID", Connection)) { Command.Parameters.AddWithValue("@GUID", Item.GUID); await Command.ExecuteNonQueryAsync().ConfigureAwait(false); } return(true); } catch (Exception ex) { LogTracer.Log(ex, $"An error was threw in { nameof(DeleteFeedBackAsync)}"); return(false); } } else { return(false); } } else { throw new ArgumentNullException(nameof(Item), "Parameter could not be null"); } }
public async Task RefreshAsync() { try { if (await CheckExistAsync(Path)) { if (LoadMorePropertiesWithFullTrustProcess()) { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { await LoadMorePropertiesCoreAsync(Exclusive.Controller, true); } } else { await LoadMorePropertiesCoreAsync(true); } OnPropertyChanged(nameof(Size)); OnPropertyChanged(nameof(Name)); OnPropertyChanged(nameof(ModifiedTime)); OnPropertyChanged(nameof(Thumbnail)); OnPropertyChanged(nameof(DisplayType)); } else { LogTracer.Log($"File/Folder not found or access deny when executing FileSystemStorageItemBase.Update, path: {Path}"); } } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw when executing FileSystemStorageItemBase.Update, path: {Path}"); } }
private static async Task <string> GetDailyPhotoPath() { try { HttpWebRequest Request = WebRequest.CreateHttp(new Uri("http://cn.bing.com/HPImageArchive.aspx?idx=0&n=1")); Request.Timeout = 5000; Request.ReadWriteTimeout = 5000; using (WebResponse Response = await Request.GetResponseAsync()) using (Stream ResponseStream = Response.GetResponseStream()) using (StreamReader Reader = new StreamReader(ResponseStream)) { string XmlString = await Reader.ReadToEndAsync(); XmlDocument Document = new XmlDocument(); Document.LoadXml(XmlString); if (Document.SelectSingleNode("/images/image/url") is IXmlNode Node) { return(Node.InnerText); } else { return(string.Empty); } } } catch (Exception ex) { LogTracer.Log(ex, "Network is not available"); return(string.Empty); } }
public async Task RemoveItem(JumpListGroup Group, params string[] PathList) { try { if (await Initialize().ConfigureAwait(false)) { bool ItemModified = false; string GroupString = ConvertGroupEnumToResourceString(Group); JumpListItem[] GroupItem = InnerList.Items.Where((Item) => Item.GroupName == GroupString).ToArray(); foreach (string Path in PathList) { if (GroupItem.FirstOrDefault((Item) => Item.Description == Path) is JumpListItem RemoveItem) { InnerList.Items.Remove(RemoveItem); ItemModified = true; } } if (ItemModified) { await InnerList.SaveAsync(); } } } catch (Exception ex) { LogTracer.Log(ex); } }
public static async Task <ProgramPickerItem> CreateAsync(AppInfo App) { try { using (IRandomAccessStreamWithContentType LogoStream = await App.DisplayInfo.GetLogo(new Windows.Foundation.Size(128, 128)).OpenReadAsync()) { BitmapDecoder Decoder = await BitmapDecoder.CreateAsync(LogoStream); using (SoftwareBitmap SBitmap = await Decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied)) using (SoftwareBitmap ResizeBitmap = ComputerVisionProvider.ResizeToActual(SBitmap)) using (InMemoryRandomAccessStream Stream = new InMemoryRandomAccessStream()) { BitmapEncoder Encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, Stream); Encoder.SetSoftwareBitmap(ResizeBitmap); await Encoder.FlushAsync(); BitmapImage Logo = new BitmapImage(); await Logo.SetSourceAsync(Stream); return(new ProgramPickerItem(Logo, App.DisplayInfo.DisplayName, App.DisplayInfo.Description, App.PackageFamilyName)); } } } catch (Exception ex) { LogTracer.Log(ex, "An exception was threw when getting or processing App Logo"); return(new ProgramPickerItem(App.DisplayInfo.DisplayName, App.DisplayInfo.Description, App.PackageFamilyName)); } }
public async Task <List <FileSystemStorageItemBase> > GetChildItemsAsync(bool IncludeHiddenItems, ItemFilters Filter = ItemFilters.File | ItemFilters.Folder) { if (WIN_Native_API.CheckLocationAvailability(Path)) { return(WIN_Native_API.GetStorageItems(Path, IncludeHiddenItems, Filter)); } else { LogTracer.Log($"Native API could not enum subitems in path: \"{Path}\", fall back to UWP storage API"); try { if (await GetStorageItemAsync().ConfigureAwait(true) is StorageFolder Folder) { QueryOptions Options = new QueryOptions { FolderDepth = FolderDepth.Shallow, IndexerOption = IndexerOption.UseIndexerWhenAvailable }; Options.SetThumbnailPrefetch(Windows.Storage.FileProperties.ThumbnailMode.ListView, 150, Windows.Storage.FileProperties.ThumbnailOptions.UseCurrentScale); Options.SetPropertyPrefetch(Windows.Storage.FileProperties.PropertyPrefetchOptions.BasicProperties, new string[] { "System.Size", "System.DateModified" }); StorageItemQueryResult Query = Folder.CreateItemQueryWithOptions(Options); uint Count = await Query.GetItemCountAsync(); List <FileSystemStorageItemBase> Result = new List <FileSystemStorageItemBase>(Convert.ToInt32(Count)); for (uint i = 0; i < Count; i += 30) { IReadOnlyList <IStorageItem> CurrentList = await Query.GetItemsAsync(i, 30); foreach (IStorageItem Item in CurrentList.Where((Item) => (Item.IsOfType(StorageItemTypes.Folder) && Filter.HasFlag(ItemFilters.Folder)) || (Item.IsOfType(StorageItemTypes.File) && Filter.HasFlag(ItemFilters.File)))) { if (Item is StorageFolder SubFolder) { Result.Add(new FileSystemStorageFolder(SubFolder, await SubFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), await SubFolder.GetModifiedTimeAsync().ConfigureAwait(true))); } else if (Item is StorageFile SubFile) { Result.Add(new FileSystemStorageFile(SubFile, await SubFile.GetThumbnailBitmapAsync().ConfigureAwait(true), await SubFile.GetSizeRawDataAsync().ConfigureAwait(true), await SubFile.GetModifiedTimeAsync().ConfigureAwait(true))); } } } return(Result); } else { return(new List <FileSystemStorageItemBase>(0)); } } catch { LogTracer.Log($"UWP API could not enum subitems in path: \"{Path}\""); return(new List <FileSystemStorageItemBase>(0)); } } }
public async Task LaunchAsync() { try { using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController()) { if (LinkType == ShellLinkType.Normal) { if (!await Exclusive.Controller.RunAsync(LinkTargetPath, WorkDirectory, WindowState, NeedRunAsAdmin, false, false, Arguments)) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_LaunchFailed_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; await Dialog.ShowAsync(); }); } } else { if (!await Exclusive.Controller.LaunchUWPFromPfnAsync(LinkTargetPath)) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_LaunchFailed_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; await Dialog.ShowAsync(); }); } } } } catch (Exception ex) { LogTracer.Log(ex); await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { QueueContentDialog Dialog = new QueueContentDialog { Title = Globalization.GetString("Common_Dialog_ErrorTitle"), Content = Globalization.GetString("QueueDialog_LaunchFailed_Content"), CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton") }; await Dialog.ShowAsync(); }); } }
public async Task <bool> CheckPurchaseStatusAsync() { try { if (ApplicationData.Current.LocalSettings.Values.TryGetValue("LicenseGrant", out object GrantState) && Convert.ToBoolean(GrantState)) { return(true); } if (PreLoadTask == null) { PreLoadStoreData(); } await PreLoadTask; if (License != null) { if (License.AddOnLicenses.Any((Item) => Item.Value.InAppOfferToken == "Donation")) { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = true; return(true); } else { if (License.IsActive) { if (License.IsTrial) { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = false; return(false); } else { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = true; return(true); } } else { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = false; return(false); } } } else { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = false; return(false); } } catch (Exception ex) { LogTracer.Log(ex, $"{nameof(CheckPurchaseStatusAsync)} threw an exception"); return(false); } }
public async Task <ulong> GetFolderSizeAsync(CancellationToken CancelToken = default) { if (WIN_Native_API.CheckLocationAvailability(Path)) { return(await Task.Run(() => { return WIN_Native_API.CalulateSize(Path, CancelToken); })); } else { try { LogTracer.Log($"Native API could not found the path: \"{Path}\", fall back to UWP storage API"); if (await GetStorageItemAsync() is StorageFolder Folder) { QueryOptions Options = new QueryOptions { FolderDepth = FolderDepth.Deep, IndexerOption = IndexerOption.UseIndexerWhenAvailable }; Options.SetPropertyPrefetch(Windows.Storage.FileProperties.PropertyPrefetchOptions.BasicProperties, new string[] { "System.Size" }); StorageFileQueryResult Query = Folder.CreateFileQueryWithOptions(Options); uint FileCount = await Query.GetItemCountAsync(); ulong TotalSize = 0; for (uint Index = 0; Index < FileCount && !CancelToken.IsCancellationRequested; Index += 50) { foreach (StorageFile File in await Query.GetFilesAsync(Index, 50)) { TotalSize += await File.GetSizeRawDataAsync().ConfigureAwait(false); if (CancelToken.IsCancellationRequested) { break; } } } return(TotalSize); } else { return(0); } } catch (Exception ex) { LogTracer.Log(ex, $"{nameof(GetFolderSizeAsync)} failed for uwp API"); return(0); } } }
public async Task <bool> CheckPurchaseStatusAsync() { try { if (ApplicationData.Current.LocalSettings.Values.TryGetValue("LicenseGrant", out object GrantState) && Convert.ToBoolean(GrantState)) { return(true); } if (HasVerifiedLicense && ApplicationData.Current.LocalSettings.Values.ContainsKey("LicenseGrant")) { return(Convert.ToBoolean(ApplicationData.Current.LocalSettings.Values["LicenseGrant"])); } else { HasVerifiedLicense = true; StoreAppLicense License = GetLicenseTask == null ? await Store.GetAppLicenseAsync() : await GetLicenseTask.ConfigureAwait(false); if (License.AddOnLicenses.Any((Item) => Item.Value.InAppOfferToken == "Donation")) { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = true; return(true); } else { if (License.IsActive) { if (License.IsTrial) { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = false; return(false); } else { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = true; return(true); } } else { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = false; return(false); } } } } catch (Exception ex) { LogTracer.Log(ex, $"{nameof(CheckPurchaseStatusAsync)} threw an exception"); return(false); } }
public override async Task <IStorageItem> GetStorageItemAsync() { try { return(StorageItem ??= (TempStorageItem ?? await StorageFolder.GetFolderFromPathAsync(Path))); } catch (Exception ex) { LogTracer.Log(ex, $"Could not get StorageFolder, Path: {Path}"); return(null); } }
public async override Task <IStorageItem> GetStorageItemAsync() { try { return(await StorageFile.GetFileFromPathAsync(Path)); } catch (Exception ex) { LogTracer.Log(ex, $"Could not get StorageFile, Path: {Path}"); return(null); } }
public static List <string> GetStorageItemsPath(string Path, bool IncludeHiddenItem, ItemFilters Filter) { if (string.IsNullOrWhiteSpace(Path)) { throw new ArgumentNullException(nameof(Path), "Argument could not be null"); } IntPtr Ptr = FindFirstFileExFromApp(System.IO.Path.Combine(Path, "*"), FINDEX_INFO_LEVELS.FindExInfoBasic, out WIN32_FIND_DATA Data, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, FIND_FIRST_EX_LARGE_FETCH); try { if (Ptr.ToInt64() != -1) { List <string> Result = new List <string>(); do { FileAttributes Attribute = (FileAttributes)Data.dwFileAttributes; if (IncludeHiddenItem || !Attribute.HasFlag(FileAttributes.Hidden)) { if (((FileAttributes)Data.dwFileAttributes).HasFlag(FileAttributes.Directory) && Filter.HasFlag(ItemFilters.Folder)) { if (Data.cFileName != "." && Data.cFileName != "..") { Result.Add(System.IO.Path.Combine(Path, Data.cFileName)); } } else if (Filter.HasFlag(ItemFilters.File)) { Result.Add(System.IO.Path.Combine(Path, Data.cFileName)); } } }while (FindNextFile(Ptr, out Data)); return(Result); } else { LogTracer.Log(new Win32Exception(Marshal.GetLastWin32Error())); return(new List <string>()); } } catch { return(new List <string>()); } finally { FindClose(Ptr); } }
private static void QueueProcessHandler() { while (true) { if (OpeartionQueue.IsEmpty) { QueueProcessSleepLocker.WaitOne(); } try { while (OpeartionQueue.TryDequeue(out OperationListBaseModel Model)) { Retry: if (Model.Status != OperationStatus.Cancelled) { if (Model is not(OperationListCompressionModel or OperationListDecompressionModel)) { if (FullTrustProcessController.AvailableControllerNum < FullTrustProcessController.DynamicBackupProcessNum) { Thread.Sleep(1000); goto Retry; } } if (AllowParalledExecution) { Thread SubThread = new Thread(() => { ExecuteSubTaskCore(Model); }) { IsBackground = true, Priority = ThreadPriority.Normal }; SubThread.Start(); } else { ExecuteSubTaskCore(Model); } } } } catch (Exception ex) { LogTracer.Log(ex, "QueueOperation threw an exception"); } } }
public static async Task <FileSystemStorageItemBase> OpenAsync(string Path) { if (System.IO.Path.GetPathRoot(Path) != Path && WIN_Native_API.GetStorageItem(Path) is FileSystemStorageItemBase Item) { return(Item); } else { LogTracer.Log($"Native API could not found the path: \"{Path}\", fall back to UWP storage API"); try { string DirectoryPath = System.IO.Path.GetDirectoryName(Path); if (string.IsNullOrEmpty(DirectoryPath)) { StorageFolder Folder = await StorageFolder.GetFolderFromPathAsync(Path); return(new FileSystemStorageFolder(Folder, await Folder.GetThumbnailBitmapAsync(), await Folder.GetModifiedTimeAsync())); } else { StorageFolder ParentFolder = await StorageFolder.GetFolderFromPathAsync(DirectoryPath); switch (await ParentFolder.TryGetItemAsync(System.IO.Path.GetFileName(Path))) { case StorageFolder Folder: { return(new FileSystemStorageFolder(Folder, await Folder.GetThumbnailBitmapAsync(), await Folder.GetModifiedTimeAsync())); } case StorageFile File: { return(new FileSystemStorageFile(File, await File.GetThumbnailBitmapAsync(), await File.GetSizeRawDataAsync(), await File.GetModifiedTimeAsync())); } default: { LogTracer.Log($"UWP storage API could not found the path: \"{Path}\""); return(null); } } } } catch (Exception ex) { LogTracer.Log(ex, $"UWP storage API could not found the path: \"{Path}\""); return(null); } } }
public static async Task <FileSystemStorageItemBase> OpenAsync(string Path) { if (WIN_Native_API.CheckLocationAvailability(System.IO.Path.GetDirectoryName(Path))) { return(WIN_Native_API.GetStorageItem(Path)); } else { LogTracer.Log($"Native API could not found the path: \"{Path}\", fall back to UWP storage API"); try { string DirectoryPath = System.IO.Path.GetDirectoryName(Path); if (string.IsNullOrEmpty(DirectoryPath)) { StorageFolder Folder = await StorageFolder.GetFolderFromPathAsync(Path); return(await CreateFromStorageItemAsync(Folder)); } else { StorageFolder ParentFolder = await StorageFolder.GetFolderFromPathAsync(DirectoryPath); switch (await ParentFolder.TryGetItemAsync(System.IO.Path.GetFileName(Path))) { case StorageFolder Folder: { return(await CreateFromStorageItemAsync(Folder)); } case StorageFile File: { return(await CreateFromStorageItemAsync(File)); } default: { LogTracer.Log($"UWP storage API could not found the path: \"{Path}\""); return(null); } } } } catch (Exception ex) { LogTracer.Log(ex, $"UWP storage API could not found the path: \"{Path}\""); return(null); } } }
public static (uint, uint) CalculateFolderAndFileCount(string Path, CancellationToken CancelToken = default) { if (string.IsNullOrWhiteSpace(Path)) { throw new ArgumentException("Argument could not be empty", nameof(Path)); } IntPtr Ptr = FindFirstFileExFromApp(System.IO.Path.Combine(Path, "*"), FINDEX_INFO_LEVELS.FindExInfoBasic, out WIN32_FIND_DATA Data, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, FIND_FIRST_EX_LARGE_FETCH); try { if (Ptr.ToInt64() != -1) { uint FolderCount = 0; uint FileCount = 0; do { if (((FileAttributes)Data.dwFileAttributes).HasFlag(FileAttributes.Directory)) { if (Data.cFileName != "." && Data.cFileName != "..") { (uint SubFolderCount, uint SubFileCount) = CalculateFolderAndFileCount(System.IO.Path.Combine(Path, Data.cFileName), CancelToken); FolderCount += ++SubFolderCount; FileCount += SubFileCount; } } else { FileCount++; } }while (FindNextFile(Ptr, out Data) && !CancelToken.IsCancellationRequested); return(FolderCount, FileCount); } else { LogTracer.Log(new Win32Exception(Marshal.GetLastWin32Error())); return(0, 0); } } catch { return(0, 0); } finally { FindClose(Ptr); } }
public static bool CheckContainsAnyItem(string Path, ItemFilters Filter) { if (string.IsNullOrWhiteSpace(Path)) { throw new ArgumentException("Argument could not be empty", nameof(Path)); } IntPtr Ptr = FindFirstFileExFromApp(System.IO.Path.Combine(Path, "*"), FINDEX_INFO_LEVELS.FindExInfoBasic, out WIN32_FIND_DATA Data, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, FIND_FIRST_EX_LARGE_FETCH); try { if (Ptr.ToInt64() != -1) { do { FileAttributes Attribute = (FileAttributes)Data.dwFileAttributes; if (!Attribute.HasFlag(FileAttributes.System)) { if (Attribute.HasFlag(FileAttributes.Directory) && Filter.HasFlag(ItemFilters.Folder)) { if (Data.cFileName != "." && Data.cFileName != "..") { return(true); } } else if (Filter.HasFlag(ItemFilters.File) && !Data.cFileName.EndsWith(".url", StringComparison.OrdinalIgnoreCase)) { return(true); } } }while (FindNextFile(Ptr, out Data)); return(false); } else { LogTracer.Log(new Win32Exception(Marshal.GetLastWin32Error())); return(false); } } catch { return(false); } finally { FindClose(Ptr); } }
public static async Task <ExtendedExecutionController> TryCreateExtendedExecution() { await SlimLocker.WaitAsync(); try { if (IsRequestExtensionSent) { return(new ExtendedExecutionController()); } else { if (Session == null) { Session = new ExtendedExecutionSession { Reason = ExtendedExecutionReason.Unspecified }; Session.Revoked += Session_Revoked; } switch (await Session.RequestExtensionAsync()) { case ExtendedExecutionResult.Allowed: { IsRequestExtensionSent = true; return(new ExtendedExecutionController()); } default: { IsRequestExtensionSent = false; LogTracer.Log("Extension execution was rejected by system"); return(null); } } } } catch (Exception ex) { LogTracer.Log(ex, "An exception was threw when creating the extended execution"); IsRequestExtensionSent = false; return(null); } finally { SlimLocker.Release(); } }
public static Task CopyToAsync(this Stream From, Stream To, long Length = -1, ProgressChangedEventHandler ProgressHandler = null, CancellationToken CancelToken = default) { return(Task.Run(() => { try { long TotalBytesRead = 0; long TotalBytesLength = Length > 0 ? Length : From.Length; byte[] DataBuffer = new byte[4096]; int ProgressValue = 0; while (true) { int bytesRead = From.Read(DataBuffer, 0, DataBuffer.Length); if (bytesRead > 0) { To.Write(DataBuffer, 0, bytesRead); TotalBytesRead += bytesRead; } else { To.Flush(); break; } if (TotalBytesLength > 1024 * 1024) { int LatestValue = Convert.ToInt32(TotalBytesRead * 100d / TotalBytesLength); if (LatestValue > ProgressValue) { ProgressValue = LatestValue; ProgressHandler.Invoke(null, new ProgressChangedEventArgs(ProgressValue, null)); } } CancelToken.ThrowIfCancellationRequested(); } } catch (Exception ex) when(ex is not OperationCanceledException) { LogTracer.Log(ex, "Could not track the progress of coping the stream"); From.CopyTo(To); } })); }
private async void Store_OfflineLicensesChanged(StoreContext sender, object args) { try { StoreAppLicense License = await sender.GetAppLicenseAsync(); if (License.IsActive && !License.IsTrial) { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = true; } } catch (Exception ex) { LogTracer.Log(ex, $"{nameof(Store_OfflineLicensesChanged)} threw an exception"); } }
public static ulong CalculateSize(string Path, CancellationToken CancelToken = default) { if (string.IsNullOrWhiteSpace(Path)) { throw new ArgumentException("Argument could not be empty", nameof(Path)); } IntPtr Ptr = FindFirstFileExFromApp(System.IO.Path.Combine(Path, "*"), FINDEX_INFO_LEVELS.FindExInfoBasic, out WIN32_FIND_DATA Data, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, FIND_FIRST_EX_LARGE_FETCH); try { if (Ptr.ToInt64() != -1) { ulong TotalSize = 0; do { if (((FileAttributes)Data.dwFileAttributes).HasFlag(FileAttributes.Directory)) { if (Data.cFileName != "." && Data.cFileName != "..") { TotalSize += CalculateSize(System.IO.Path.Combine(Path, Data.cFileName), CancelToken); } } else { TotalSize += ((ulong)Data.nFileSizeHigh << 32) + Data.nFileSizeLow; } }while (FindNextFile(Ptr, out Data) && !CancelToken.IsCancellationRequested); return(TotalSize); } else { LogTracer.Log(new Win32Exception(Marshal.GetLastWin32Error())); return(0); } } catch { return(0); } finally { FindClose(Ptr); } }
private void View_PointerMoved(object sender, PointerRoutedEventArgs e) { if (AllowProcess && e.Pointer.PointerDeviceType == PointerDeviceType.Mouse && e.GetCurrentPoint(View).Properties.IsLeftButtonPressed) { if (Interlocked.Exchange(ref Locker, 1) == 0) { try { Point RelativeEndPoint = e.GetCurrentPoint(View).Position; SrcollIfNeed(RelativeEndPoint); Point RelativeStartPoint = new Point(AbsStartPoint.X - InnerScrollView.HorizontalOffset, AbsStartPoint.Y - InnerScrollView.VerticalOffset); DrawRectangleInCanvas(RelativeStartPoint, RelativeEndPoint); GeneralTransform AbsToWindowTransform = View.TransformToVisual(Window.Current.Content); Rect SelectedRect = new Rect(RelativeStartPoint, RelativeEndPoint); if (SelectedRect.Width >= 20 && SelectedRect.Height >= 20) { IEnumerable <FileSystemStorageItemBase> SelectedList = VisualTreeHelper.FindElementsInHostCoordinates(AbsToWindowTransform.TransformBounds(SelectedRect), View).OfType <SelectorItem>().Select((Item) => Item.Content as FileSystemStorageItemBase); foreach (FileSystemStorageItemBase Item in View.SelectedItems.OfType <FileSystemStorageItemBase>().Except(SelectedList).Where((Item) => (View.ContainerFromItem(Item) as SelectorItem).IsVisibleOnContainer(View))) { View.SelectedItems.Remove(Item); } foreach (FileSystemStorageItemBase Item in SelectedList.Except(View.SelectedItems.OfType <FileSystemStorageItemBase>())) { View.SelectedItems.Add(Item); } } } catch (Exception ex) { LogTracer.Log(ex); } finally { _ = Interlocked.Exchange(ref Locker, 0); } } } }
public static async Task <bool> CheckExistAsync(string Path) { if (!string.IsNullOrEmpty(Path) && System.IO.Path.IsPathRooted(Path)) { if (WIN_Native_API.CheckLocationAvailability(System.IO.Path.GetDirectoryName(Path))) { return(WIN_Native_API.CheckExist(Path)); } else { try { string DirectoryPath = System.IO.Path.GetDirectoryName(Path); if (string.IsNullOrEmpty(DirectoryPath)) { await StorageFolder.GetFolderFromPathAsync(Path); return(true); } else { StorageFolder Folder = await StorageFolder.GetFolderFromPathAsync(DirectoryPath); if (await Folder.TryGetItemAsync(System.IO.Path.GetFileName(Path)) != null) { return(true); } else { return(false); } } } catch (Exception ex) { LogTracer.Log(ex, "CheckExist threw an exception"); return(false); } } } else { return(false); } }
public async Task <StorePurchaseStatus> PurchaseAsync() { try { if (PreLoadTask == null) { PreLoadStoreData(); } await PreLoadTask; if (ProductResult != null && ProductResult.ExtendedError == null) { if (ProductResult.Product != null) { StorePurchaseResult Result = await ProductResult.Product.RequestPurchaseAsync(); switch (Result.Status) { case StorePurchaseStatus.AlreadyPurchased: case StorePurchaseStatus.Succeeded: { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = true; break; } } return(Result.Status); } else { return(StorePurchaseStatus.NetworkError); } } else { return(StorePurchaseStatus.NetworkError); } } catch (Exception ex) { LogTracer.Log(ex, $"{nameof(PurchaseAsync)} threw an exception"); return(StorePurchaseStatus.NetworkError); } }
public static async Task LoadDeviceAsync() { if (Interlocked.Exchange(ref LoadDriveLockResource, 1) == 0) { try { if (!IsDriveLoaded) { IsDriveLoaded = true; foreach (DriveInfo Drive in DriveInfo.GetDrives().Where((Drives) => Drives.DriveType == DriveType.Fixed || Drives.DriveType == DriveType.Removable || Drives.DriveType == DriveType.Network) .Where((NewItem) => DriveList.All((Item) => Item.Folder.Path != NewItem.RootDirectory.FullName))) { try { StorageFolder DriveFolder = await StorageFolder.GetFolderFromPathAsync(Drive.RootDirectory.FullName); DriveList.Add(await DriveRelatedData.CreateAsync(DriveFolder, Drive.DriveType)); } catch (Exception ex) { LogTracer.Log(ex, $"Hide the device \"{Drive.RootDirectory.FullName}\" for error"); } } switch (PortalDeviceWatcher.Status) { case DeviceWatcherStatus.Created: case DeviceWatcherStatus.Aborted: case DeviceWatcherStatus.Stopped: { PortalDeviceWatcher.Start(); break; } } NetworkDriveCheckTimer.Start(); } } finally { _ = Interlocked.Exchange(ref LoadDriveLockResource, 0); } } }
public async Task <StorePurchaseStatus> PurchaseAsync() { try { await Task.Run(() => { InitLocker.WaitOne(); }); StoreProductResult ProductResult = await Store.GetStoreProductForCurrentAppAsync(); if (ProductResult.ExtendedError == null) { if (ProductResult.Product != null) { StorePurchaseResult Result = await ProductResult.Product.RequestPurchaseAsync(); switch (Result.Status) { case StorePurchaseStatus.AlreadyPurchased: case StorePurchaseStatus.Succeeded: { ApplicationData.Current.LocalSettings.Values["LicenseGrant"] = true; break; } } return(Result.Status); } else { return(StorePurchaseStatus.NetworkError); } } else { return(StorePurchaseStatus.NetworkError); } } catch (Exception ex) { LogTracer.Log(ex, $"{nameof(PurchaseAsync)} threw an exception"); return(StorePurchaseStatus.NetworkError); } }