private async void LoadDiagrams() { if (this.DiagramType == DiagramType.UML) { StorageFolder umlfile = await installedLocation.CreateFolderAsync("UML", CreationCollisionOption.OpenIfExists); IReadOnlyList <StorageFile> files = await umlfile.GetFilesAsync(); ObservableCollection <FileItem> items = new ObservableCollection <FileItem>(); string[] predefinedDiagrams = new string[] { "Diagram.xml", "Hospital.xml", "University.xml" }; if (files.Where(file => file.FileType == ".xml").Count() == 0) { foreach (string file in predefinedDiagrams) { String ResourceReference = "ms-appx:///Showcase/UMLDiagramDesigner/PreSavedUML/" + file; StorageFile f = await StorageFile.GetFileFromApplicationUriAsync(new Uri(ResourceReference, UriKind.Absolute)); await f.CopyAsync(umlfile, f.Name); } files = await umlfile.GetFilesAsync(); } PopulateGridView(files, items); } else if (this.DiagramType == DiagramType.MindMap) { StorageFolder mindmapfile = await installedLocation.CreateFolderAsync("MindMap", CreationCollisionOption.OpenIfExists); IReadOnlyList <StorageFile> files = await mindmapfile.GetFilesAsync(); ObservableCollection <FileItem> items = new ObservableCollection <FileItem>(); string[] predefinedDiagrams = new string[] { "ElementTree.xml", "Feelings.xml", "MindMap.xml" }; if (files.Where(file => file.FileType == ".xml").Count() == 0) { foreach (string file in predefinedDiagrams) { String ResourceReference = "ms-appx:///Showcase/MindMapDemo/PreSavedMindMap/" + file; StorageFile f = await StorageFile.GetFileFromApplicationUriAsync(new Uri(ResourceReference, UriKind.Absolute)); await f.CopyAsync(mindmapfile, f.Name); } files = await mindmapfile.GetFilesAsync(); } PopulateGridView(files, items); } else if (this.DiagramType == DiagramType.WorkFlow) { StorageFolder workflowfile = await installedLocation.CreateFolderAsync("WorkFlow", CreationCollisionOption.OpenIfExists); IReadOnlyList <StorageFile> files = await workflowfile.GetFilesAsync(); ObservableCollection <FileItem> items = new ObservableCollection <FileItem>(); string[] predefinedDiagrams = new string[] { "Make ice cream.xml", "Doctor appointment.xml", "Support Workflow.xml" }; if (files.Where(file => file.FileType == ".xml").Count() == 0) { foreach (string file in predefinedDiagrams) { String ResourceReference = "ms-appx:///Showcase/WorkFlowEditor/PreSavedWorkFlow/" + file; StorageFile f = await StorageFile.GetFileFromApplicationUriAsync(new Uri(ResourceReference, UriKind.Absolute)); await f.CopyAsync(workflowfile, f.Name); } files = await workflowfile.GetFilesAsync(); } PopulateGridView(files, items); } else if (this.DiagramType == DiagramType.FloorPlan) { StorageFolder floorplanfile = await installedLocation.CreateFolderAsync("FloorPlan", CreationCollisionOption.OpenIfExists); IReadOnlyList <StorageFile> files = await floorplanfile.GetFilesAsync(); ObservableCollection <FileItem> items = new ObservableCollection <FileItem>(); //"FloorPlan1.xml", string[] predefinedDiagrams = new string[] { "FloorPlan.xml" }; if (files.Where(file => file.FileType == ".xml").Count() == 0) { foreach (string file in predefinedDiagrams) { String ResourceReference = "ms-appx:///Showcase/FloorPlannerDemo/PresavedFloorPlan/" + file; StorageFile f = await StorageFile.GetFileFromApplicationUriAsync(new Uri(ResourceReference, UriKind.Absolute)); await f.CopyAsync(floorplanfile, f.Name); } files = await floorplanfile.GetFilesAsync(); } PopulateGridView(files, items); } }
public static DirectoryInfo CreateDirectory(string path) { if (path == null) { throw new ArgumentNullException(); } if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentNullException("Path is empty"); } StorageFolder folder = (StorageFolder)null; path = path.Replace('/', '\\'); string path1 = path; Stack <string> stack = new Stack <string>(); do { try { folder = Directory.GetDirectoryForPath(path1); break; } catch { int length = path1.LastIndexOf('\\'); if (length < 0) { path1 = (string)null; } else { stack.Push(path1.Substring(length + 1)); path1 = path1.Substring(0, length); } } }while (path1 != null); if (path1 == null) { System.Diagnostics.Debug.WriteLine("Directory.CreateDirectory: Could not find any part of the path: " + path); throw new IOException("Could not find any part of the path: " + path); } try { while (stack.Count > 0) { string desiredName = stack.Pop(); if (string.IsNullOrWhiteSpace(desiredName) && stack.Count > 0) { throw new ArgumentNullException("Empty directory name in the path"); } IAsyncOperation <StorageFolder> folderAsync = folder.CreateFolderAsync(desiredName); WindowsRuntimeSystemExtensions.AsTask <StorageFolder>(folderAsync).Wait(); folder = folderAsync.GetResults(); } return(new DirectoryInfo(path, folder)); } catch (IOException ex) { System.Diagnostics.Debug.WriteLine("Directory.CreateDirectory: " + ex.Message + "\n" + ex.StackTrace); throw; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Directory.CreateDirectory: " + ex.Message + "\n" + ex.StackTrace); throw new IOException(ex.Message, ex); } }
/// <summary> /// Initializes the controller: Loads settings, starts web server, sets up the camera and storage providers, /// tries to log into OneDrive (if OneDrive is selected), and starts the file upload and deletion timers /// </summary> /// <returns></returns> public async Task Initialize() { try { // Load settings from file XmlSettings = await AppSettings.RestoreAsync("Settings.xml"); // Create securitysystem-cameradrop sub folder if it doesn't exist StorageFolder folder = KnownFolders.PicturesLibrary; if (await folder.TryGetItemAsync(AppSettings.FolderName) == null) { await folder.CreateFolderAsync(AppSettings.FolderName); } // Start web server on port 8000 if (!Server.IsRunning) { Server.Start(8000); } Camera = CameraFactory.Get(XmlSettings.CameraType); Storage = StorageFactory.Get(XmlSettings.StorageProvider); await Camera.Initialize(); // Try to log into OneDrive using existing Access Token in settings file if (Storage.GetType() == typeof(OneDrive)) { var oneDrive = App.Controller.Storage as OneDrive; if (oneDrive != null) { if (!oneDrive.IsLoggedIn()) { try { await oneDrive.AuthorizeWithRefreshToken(XmlSettings.OneDriveRefreshToken); } catch (Exception ex) { Debug.WriteLine(ex.Message); // Log telemetry event about this exception var events = new Dictionary <string, string> { { "Controller", ex.Message } }; TelemetryHelper.TrackEvent("FailedToLoginOneDrive", events); } } } } this.alljoynManager = new AllJoynManager(); await this.alljoynManager.Initialize(this.Camera, this.Storage); //Timer controlling camera pictures with motion uploadPicturesTimer = new DispatcherTimer(); uploadPicturesTimer.Interval = TimeSpan.FromSeconds(uploadInterval); uploadPicturesTimer.Tick += uploadPicturesTimer_Tick; uploadPicturesTimer.Start(); //Timer controlling deletion of old pictures deletePicturesTimer = new DispatcherTimer(); deletePicturesTimer.Interval = TimeSpan.FromHours(deleteInterval); deletePicturesTimer.Tick += deletePicturesTimer_Tick; deletePicturesTimer.Start(); IsInitialized = true; } catch (Exception ex) { Debug.WriteLine("Controller.Initialize() Error: " + ex.Message); // Log telemetry event about this exception var events = new Dictionary <string, string> { { "Controller", ex.Message } }; TelemetryHelper.TrackEvent("FailedToInitialize", events); } }
public async Task <Foto> GetSponsorImageAsync(Guid verenigingId, Guid afbeeldingId) { Foto foto = new Foto(); StorageFile image = null; Sponsor sponsor = _cachedSponsors.SingleOrDefault(s => s.AfbeeldingId == afbeeldingId); //StorageFolder _folder = Windows.Storage.ApplicationData.Current.TemporaryFolder; //StorageFolder _fotos = await _folder.CreateFolderAsync("Sponsors", CreationCollisionOption.OpenIfExists); //string _filename = sponsorId + ".jpg"; //image = await _fotos.CreateFileAsync(_filename, CreationCollisionOption.ReplaceExisting); //foto.Path = image.Path; if (sponsor != null) { string filename = sponsor.Id + ".jpg"; StorageFolder folder = Windows.Storage.ApplicationData.Current.TemporaryFolder; StorageFolder fotos = await folder.CreateFolderAsync("Sponsors", CreationCollisionOption.OpenIfExists); image = await fotos.TryGetItemAsync(filename) as StorageFile; try { if (image != null) { await image.DeleteAsync(StorageDeleteOption.PermanentDelete); } if (image == null) { foto = await _sponsorService.GetSponsorImageByIdAsync(verenigingId, afbeeldingId); if (foto != null) { image = await fotos.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); IBuffer writebuffer = GetBufferFromContentData(foto.ContentData); await Windows.Storage.FileIO.WriteBufferAsync(image, writebuffer); foto.Path = image.Path; } } } catch (Exception ex) { string message = ex.Message; } /* * try * { * IBuffer readbuffer = await FileIO.ReadBufferAsync(image); * * if (foto.ContentData != null) * foto.ContentData = new byte[readbuffer.Length]; * * foto.ContentData = readbuffer.ToArray(); * } * catch (Exception ex) * { * string message = ex.Message; * } */ } return(foto); }
/// <summary> /// Downloads mixed reality files from the device. /// </summary> /// <param name="parentFolder">The parent folder which will contain the device specific folder.</param> /// <param name="deleteAfterDownload">Value indicating whether or not files are to be deleted /// from the device after they have been downloaded.</param> /// <returns>The name of the folder in to which the files were downloaded.</returns> internal async Task <string> GetMixedRealityFilesAsync( StorageFolder parentFolder, bool deleteAfterDownload) { string folderName = null; if (this.IsConnected && this.IsSelected) { try { MrcFileList fileList = await this.deviceMonitor.GetMixedRealityFileListAsync(); if (fileList.Files.Count != 0) { // Create the folder for this device's files. StorageFolder folder = await parentFolder.CreateFolderAsync( (string.IsNullOrWhiteSpace(this.Name) ? this.Address : this.Name), CreationCollisionOption.OpenIfExists); folderName = folder.Name; foreach (MrcFileInformation fileInfo in fileList.Files) { try { byte[] fileData = await this.deviceMonitor.GetMixedRealityFileAsync(fileInfo.FileName); StorageFile file = await folder.CreateFileAsync( fileInfo.FileName, CreationCollisionOption.ReplaceExisting); using (Stream stream = await file.OpenStreamForWriteAsync()) { await stream.WriteAsync(fileData, 0, fileData.Length); await stream.FlushAsync(); } this.StatusMessage = string.Format( "{0} downloaded", fileInfo.FileName); if (deleteAfterDownload) { await this.deviceMonitor.DeleteMixedRealityFile(fileInfo.FileName); } } catch (Exception e) { this.StatusMessage = string.Format( "Failed to download {0} - {1}", fileInfo.FileName, e.Message); } } } } catch (Exception e) { this.StatusMessage = string.Format( "Failed to get mixed reality files - {0}", e.Message); } } return(folderName); }
/// <summary> /// Take a photo async with specified options /// </summary> /// <param name="options">Camera Media Options</param> /// <returns>Media file of photo or null if canceled</returns> public async Task <MediaFile> TakePhotoAsync(StoreCameraMediaOptions options) { if (!initialized) { await Initialize(); } if (!IsCameraAvailable) { throw new NotSupportedException(); } options.VerifyOptions(); var capture = new CameraCaptureUI(); capture.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg; capture.PhotoSettings.MaxResolution = GetMaxResolution(options?.PhotoSize ?? PhotoSize.Full, options?.CustomPhotoSize ?? 100); //we can only disable cropping if resolution is set to max if (capture.PhotoSettings.MaxResolution == CameraCaptureUIMaxPhotoResolution.HighestAvailable) { capture.PhotoSettings.AllowCropping = options?.AllowCropping ?? true; } var result = await capture.CaptureFileAsync(CameraCaptureUIMode.Photo); if (result == null) { return(null); } StorageFolder folder = ApplicationData.Current.LocalFolder; string path = options.GetFilePath(folder.Path); var directoryFull = Path.GetDirectoryName(path); var newFolder = directoryFull.Replace(folder.Path, string.Empty); if (!string.IsNullOrWhiteSpace(newFolder)) { await folder.CreateFolderAsync(newFolder, CreationCollisionOption.OpenIfExists); } folder = await StorageFolder.GetFolderFromPathAsync(directoryFull); string filename = Path.GetFileName(path); string aPath = null; if (options?.SaveToAlbum ?? false) { try { string fileNameNoEx = Path.GetFileNameWithoutExtension(path); var copy = await result.CopyAsync(KnownFolders.PicturesLibrary, fileNameNoEx + result.FileType, NameCollisionOption.GenerateUniqueName); aPath = copy.Path; } catch (Exception ex) { Debug.WriteLine("unable to save to album:" + ex); } } var file = await result.CopyAsync(folder, filename, NameCollisionOption.GenerateUniqueName).AsTask(); return(new MediaFile(file.Path, () => file.OpenStreamForReadAsync().Result, albumPath: aPath)); }
public void Initialize(Lua.lua_State L) { DrawableParser = LGDrawableParser.Instance; DimensionParser = LGDimensionParser.Instance; ColorParser = LGColorParser.Instance; StringParser = LGStringParser.Instance; List <String> lst = new List <String>(); lst.Add("ld"); MatchStringsStart.Add(lst); lst = new List <String>(); lst.Add("sw"); MatchStringsStart.Add(lst); lst = new List <String>(); lst.Add("w"); MatchStringsStart.Add(lst); lst = new List <String>(); lst.Add("h"); MatchStringsStart.Add(lst); lst = new List <String>(); lst.Add("small"); lst.Add("normal"); lst.Add("large"); lst.Add("xlarge"); MatchStringsStart.Add(lst); lst = new List <String>(); lst.Add("port"); lst.Add("land"); MatchStringsStart.Add(lst); lst = new List <String>(); lst.Add("ldpi"); lst.Add("mdpi"); lst.Add("hdpi"); lst.Add("xhdpi"); lst.Add("nodpi"); MatchStringsStart.Add(lst); lst = new List <String>(); lst.Add("v"); MatchStringsStart.Add(lst); lst = new List <String>(); MatchStringsEnd.Add(lst); lst = new List <String>(); lst.Add("dp"); MatchStringsEnd.Add(lst); lst = new List <String>(); lst.Add("dp"); MatchStringsEnd.Add(lst); lst = new List <String>(); lst.Add("dp"); MatchStringsEnd.Add(lst); lst = new List <String>(); MatchStringsEnd.Add(lst); lst = new List <String>(); MatchStringsEnd.Add(lst); lst = new List <String>(); MatchStringsEnd.Add(lst); lst = new List <String>(); switch (LuaEngine.Instance.GetPrimaryLoad()) { case LuaEngine.EXTERNAL_DATA: { #if NETFX_CORE StorageFolder internalScriptsFolder = null; /*String[] scriptRootArr = scriptsRoot.Split('/'); * foreach (String scriptRootPart in scriptRootArr)*/ String uiRoot = LuaEngine.Instance.GetUIRoot().Replace("/", "\\"); internalScriptsFolder = Package.Current.InstalledLocation.GetFolderAsync(uiRoot).AsTask().Synchronize(); IReadOnlyList <StorageFile> files = internalScriptsFolder.GetFilesAsync().AsTask().Synchronize(); String rootPath = ApplicationData.Current.LocalFolder.Path; StorageFolder rootFolder = ApplicationData.Current.LocalFolder; StorageFolder scriptsFolder = null; if (LuaEngine.Instance.GetForceLoad() > 0) { try { StorageFolder sf = rootFolder.GetFolderAsync(uiRoot).AsTask().Synchronize(); sf.DeleteAsync().AsTask().Synchronize(); } catch { } scriptsFolder = rootFolder.CreateFolderAsync(uiRoot, CreationCollisionOption.ReplaceExisting).AsTask().Synchronize(); } else { scriptsFolder = rootFolder.CreateFolderAsync(uiRoot, CreationCollisionOption.OpenIfExists).AsTask().Synchronize(); } foreach (StorageFile fileSF in files) { String file = fileSF.Name; Stream sr = Defines.GetResourceAsset(uiRoot + "/", file); StorageFile toWrite = scriptsFolder.CreateFileAsync(file, CreationCollisionOption.ReplaceExisting).AsTask().Synchronize(); var toWriteStream = toWrite.OpenTransactedWriteAsync().AsTask().Synchronize(); byte[] buffer = new byte[1024]; int length = 0; while ((length = sr.Read(buffer, 0, buffer.Length)) > 0) { toWriteStream.Stream.WriteAsync(buffer.AsBuffer()).AsTask().Synchronize(); } toWriteStream.CommitAsync().AsTask().Synchronize(); toWriteStream.Dispose(); } #endif } break; case LuaEngine.INTERNAL_DATA: case LuaEngine.RESOURCE_DATA: { } break; } ParseValues(L); DrawableParser.Initialize(L); }
private async Task CreateFolderAsync(StorageFolder folder, string folderPath) { await folder.CreateFolderAsync(folderPath, CreationCollisionOption.OpenIfExists); }
private async void Start() { if (_tempResultsFolder == null) { _tempResultsFolder = await ApplicationData.Current.TemporaryFolder.CreateFolderAsync("Results", CreationCollisionOption.OpenIfExists); _sourceHostConfigsFolder = await _expectedFolder.CreateFolderAsync("SourceHostConfigs", CreationCollisionOption.OpenIfExists); _sourceCardsFolder = await _expectedFolder.CreateFolderAsync("SourceCards", CreationCollisionOption.OpenIfExists); } CurrentCardVisual = null; // If no cards left if (RemainingCards.Count == 0) { if (RemainingHostConfigs.Count != 0) { RemainingHostConfigs.RemoveAt(0); } _addToTimeline = false; // If also no host configs left, done if (RemainingHostConfigs.Count == 0) { GoToDoneState(); return; } // Otherwise reset the cards and pop off the current host config foreach (var c in _originalCards) { RemainingCards.Add(c); } } // Delay a bit to allow UI thread to update, otherwise user would never see an update await Task.Delay(10); var card = RemainingCards.First(); CurrentCard = card.Name; if (RemainingHostConfigs.Count != 0) { CurrentHostConfig = RemainingHostConfigs.First().Name; var testResult = await TestCard(card, RemainingHostConfigs.First()); Results.Add(testResult); } if (_addToTimeline) { await AddCardToTimeline(card); } RemainingCards.RemoveAt(0); // And start the process again Start(); }
public async static Task <StorageFile> CreateFile(Mission m, string name) { StorageFolder sf = await rsf.CreateFolderAsync(m.vid, CreationCollisionOption.OpenIfExists); return(await sf.CreateFileAsync(name, CreationCollisionOption.OpenIfExists)); }
private async Task <StorageFolder> GetFolderForFile(StorageFolder folder, string dirStructure) { string[] namesFolders = dirStructure.Split('/'); StorageFolder newFolder = folder; foreach (var item in namesFolders) { var tmpFolder = await newFolder.TryGetItemAsync(item) == null ? await newFolder.CreateFolderAsync(item) : await newFolder.GetFolderAsync(item); newFolder = tmpFolder; } return(newFolder); }
async void doInit(StorageFolder root, string directory) { folder = await root.CreateFolderAsync(directory, CreationCollisionOption.OpenIfExists); }
/// <summary> /// Creates a directory in the storage scope. /// </summary> /// <param name="dir">The relative path of the directory to create within the storage.</param> /// <returns>The <see cref="Task"/> object representing the asynchronous operation.</returns> public async Task CreateDirectoryAsync(string dir) { await Storage.CreateFolderAsync(dir); }
private async Task FetchFilesToDownload(string remotePath, StorageFolder localFolder, ICollection <FileTransferInfo> resultOutput, BooleanReference overwriteAll, BooleanReference skipAll, BooleanReference cancelAll) { var remoteFiles = await client.GetListingAsync(remotePath); foreach (var item in remoteFiles) { if (cancelAll.Value) { return; } if (item.Type == FluentFTP.FtpFileSystemObjectType.File) { StorageFile file = null; if (overwriteAll.Value) { file = await localFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); } else { try { file = await localFolder.CreateFileAsync(item.Name, CreationCollisionOption.FailIfExists); } catch //TODO: catch what? { if (skipAll.Value) { continue; } OverwriteDialog content = new OverwriteDialog { Text = string.Format("文件{0}已存在,是否覆盖?", item.Name), CheckBoxText = "对所有项目执行此操作" }; ContentDialog dialog = new ContentDialog() { Content = content, PrimaryButtonText = "覆盖", IsPrimaryButtonEnabled = true, SecondaryButtonText = "跳过", IsSecondaryButtonEnabled = true, CloseButtonText = "取消" }; switch (await dialog.ShowAsync()) { case ContentDialogResult.Primary: if (content.IsChecked) { overwriteAll.Value = true; } file = await localFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); break; case ContentDialogResult.Secondary: if (content.IsChecked) { skipAll.Value = true; } continue; case ContentDialogResult.None: cancelAll.Value = true; return; } } } resultOutput.Add(new FileTransferInfo { File = file, RemotePath = item.FullName }); } else { var subFolder = await localFolder.CreateFolderAsync(item.Name, CreationCollisionOption.OpenIfExists); await FetchFilesToDownload(item.FullName, subFolder, resultOutput, overwriteAll, skipAll, cancelAll); } } }
public async Task <Boolean> SynchronizeTrip(Trip _trip) { Boolean _status = true; String _id = LocalSettings.LoadStorageValue <String>(LOCAL_OAUTH_TOKEN); StorageFolder _rootGT = await getDeviceGTFolder(_id); if (_rootGT == null) { return(false); } ProgressUpdate(Res.GetString("SynchroTrip") + " " + _trip.Summary.FolderTopName, 0); IReadOnlyList <StorageFolder> _folders = await _rootGT.GetFoldersAsync(); StorageFolder _rootTrip = null; Boolean _found = false; String _tripName = _trip.Summary.FolderTopName; foreach (StorageFolder _item in _folders) { if (_item.Name.Equals(_tripName)) { _rootTrip = _item as StorageFolder; _found = true; break; } } if (!_found) { _rootTrip = await _rootGT.CreateFolderAsync(_tripName, CreationCollisionOption.OpenIfExists); } _folders = await _rootTrip.GetFoldersAsync(); //check if all dropbox folders are synchronized with local folders foreach (Album _album in _trip.Albums) { _found = false; StorageFolder _folderAlbum = null; foreach (StorageFolder _item in _folders) { if ((_rootTrip.Path + "\\" + _album.DisplayName == _item.Path)) { _folderAlbum = _item; _found = true; break; } } if (!_found) { _folderAlbum = await _rootTrip.CreateFolderAsync(_album.DisplayName, CreationCollisionOption.OpenIfExists); } _status &= await synchronizeAlbum(_album, _folderAlbum, _trip.Summary); if (!_status || CancelInProgress()) { return(false); } } return(true); }
public static async Task <FileSystemStorageItemBase> CreateAsync(string Path, StorageItemTypes ItemTypes, CreateOption Option) { switch (ItemTypes) { case StorageItemTypes.File: { if (WIN_Native_API.CreateFileFromPath(Path, Option, out string NewPath)) { return(await OpenAsync(NewPath)); } else { LogTracer.Log($"Native API could not create file: \"{Path}\", fall back to UWP storage API"); try { StorageFolder Folder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(Path)); switch (Option) { case CreateOption.GenerateUniqueName: { StorageFile NewFile = await Folder.CreateFileAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.GenerateUniqueName); return(await CreatedByStorageItemAsync(NewFile)); } case CreateOption.OpenIfExist: { StorageFile NewFile = await Folder.CreateFileAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.OpenIfExists); return(await CreatedByStorageItemAsync(NewFile)); } case CreateOption.ReplaceExisting: { StorageFile NewFile = await Folder.CreateFileAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.ReplaceExisting); return(await CreatedByStorageItemAsync(NewFile)); } default: { return(null); } } } catch { LogTracer.Log($"UWP storage API could not create file: \"{Path}\""); return(null); } } } case StorageItemTypes.Folder: { if (WIN_Native_API.CreateDirectoryFromPath(Path, Option, out string NewPath)) { return(await OpenAsync(NewPath)); } else { LogTracer.Log($"Native API could not create file: \"{Path}\", fall back to UWP storage API"); try { StorageFolder Folder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(Path)); switch (Option) { case CreateOption.GenerateUniqueName: { StorageFolder NewFolder = await Folder.CreateFolderAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.GenerateUniqueName); return(await CreatedByStorageItemAsync(NewFolder)); } case CreateOption.OpenIfExist: { StorageFolder NewFolder = await Folder.CreateFolderAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.OpenIfExists); return(await CreatedByStorageItemAsync(NewFolder)); } case CreateOption.ReplaceExisting: { StorageFolder NewFolder = await Folder.CreateFolderAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.ReplaceExisting); return(await CreatedByStorageItemAsync(NewFolder)); } default: { return(null); } } } catch { LogTracer.Log($"UWP storage API could not create folder: \"{Path}\""); return(null); } } } default: { return(null); } } }
/// <summary> /// Gets an image and saves it locally. /// </summary> /// <param name="postUrl"></param> public void SaveImageLocally(string postUrl) { try { string imageUrl = GetImageUrl(postUrl); // Fire off a request for the image. Random rand = new Random((int)DateTime.Now.Ticks); ImageManagerRequest request = new ImageManagerRequest() { ImageId = rand.NextDouble().ToString(), Url = imageUrl }; // Set the callback request.OnRequestComplete += async(object sender, ImageManager.ImageManagerResponseEventArgs response) => { try { // If success if (response.Success) { // Get the photos library StorageLibrary myPictures = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Pictures); // Get the save folder StorageFolder saveFolder = myPictures.SaveFolder; // Try to find the saved pictures folder StorageFolder savedPicturesFolder = null; IReadOnlyList <StorageFolder> folders = await saveFolder.GetFoldersAsync(); foreach (StorageFolder folder in folders) { if (folder.DisplayName.Equals("Saved Pictures")) { savedPicturesFolder = folder; } } // If not found create it. if (savedPicturesFolder == null) { savedPicturesFolder = await saveFolder.CreateFolderAsync("Saved Pictures"); } // Write the file. StorageFile file = await savedPicturesFolder.CreateFileAsync($"Baconit Saved Image {DateTime.Now.ToString("MM-dd-yy H.mm.ss")}.jpg"); using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await RandomAccessStream.CopyAndCloseAsync(response.ImageStream.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0)); } // Tell the user m_baconMan.MessageMan.ShowMessageSimple("Image Saved", "You can find the image in the 'Saved Pictures' folder in your photos library."); } } catch (Exception ex) { m_baconMan.TelemetryMan.ReportUnExpectedEvent(this, "FailedToSaveImageLocallyCallback", ex); m_baconMan.MessageMan.DebugDia("failed to save image locally in callback", ex); } }; QueueImageRequest(request); } catch (Exception e) { m_baconMan.TelemetryMan.ReportUnExpectedEvent(this, "FailedToSaveImageLocally", e); m_baconMan.MessageMan.DebugDia("failed to save image locally", e); } }
public async Task SaveToFile(string collection) { var invalids = System.IO.Path.GetInvalidFileNameChars(); var filename = string.Join("_", Name.Split(invalids, StringSplitOptions.RemoveEmptyEntries)).TrimEnd('.') + ".gpx"; var serializer = new XmlSerializer(typeof(gpxType)); StorageFolder FavoritesFolder = await ApplicationData.Current.RoamingFolder.CreateFolderAsync("Routes", CreationCollisionOption.OpenIfExists); if (collection != "") { FavoritesFolder = await FavoritesFolder.CreateFolderAsync(collection, CreationCollisionOption.OpenIfExists); } StorageFile file = await FavoritesFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); Stream stream = await file.OpenStreamForWriteAsync(); using (stream) { gpxType objectToSave = new gpxType() { metadata = new metadataType() { name = Name, desc = Description, extensions = new extensionsType() { symbol = Symbol // TODO: Add distance, uphill, downhill and so on }, author = new personType() { name = "Cyke Maps" }, timeSpecified = true, time = Timestamp }, creator = "Cyke Maps", wpt = new wptType[] { new wptType() { name = "StartPoint", lat = (decimal)StartPoint.Location.Position.Latitude, lon = (decimal)StartPoint.Location.Position.Longitude, eleSpecified = true, ele = (decimal)StartPoint.Location.Position.Altitude } }, trk = new trkType[] // Add a gpx track with the Track from the route { new trkType() { trkseg = new trksegType[] { new trksegType() { trkpt = Track.Select(pos => new wptType() // Convert the Track from the route to a wptType[] Array { lat = (decimal)pos.Latitude, lon = (decimal)pos.Longitude, ele = (decimal)pos.Altitude, eleSpecified = true }).ToArray() } } } } }; serializer.Serialize(stream, objectToSave); } // Reload the Favorites LibraryManager.Current.Reload(ReloadParameter.Routes); }
public static async void CreateFile(AddItemType fileType) { var TabInstance = App.CurrentInstance; string currentPath = null; if (TabInstance.ContentPage != null) { currentPath = TabInstance.ViewModel.WorkingDirectory; } StorageFolder folderToCreateItem = await StorageFolder.GetFolderFromPathAsync(currentPath); RenameDialog renameDialog = new RenameDialog(); var renameResult = await renameDialog.ShowAsync(); if (renameResult == ContentDialogResult.Secondary) { return; } var userInput = renameDialog.storedRenameInput; if (fileType == AddItemType.Folder) { StorageFolder folder; if (!string.IsNullOrWhiteSpace(userInput)) { folder = await folderToCreateItem.CreateFolderAsync(userInput, CreationCollisionOption.GenerateUniqueName); } else { folder = await folderToCreateItem.CreateFolderAsync(ResourceController.GetTranslation("NewFolder"), CreationCollisionOption.GenerateUniqueName); } TabInstance.ViewModel.AddFileOrFolder(new ListedItem(folder.FolderRelativeId) { PrimaryItemAttribute = StorageItemTypes.Folder, ItemName = folder.DisplayName, ItemDateModifiedReal = DateTimeOffset.Now, LoadUnknownTypeGlyph = false, LoadFolderGlyph = true, LoadFileIcon = false, ItemType = "Folder", FileImage = null, ItemPath = folder.Path }); } else if (fileType == AddItemType.TextDocument) { StorageFile item; if (!string.IsNullOrWhiteSpace(userInput)) { item = await folderToCreateItem.CreateFileAsync(userInput + ".txt", CreationCollisionOption.GenerateUniqueName); } else { item = await folderToCreateItem.CreateFileAsync(ResourceController.GetTranslation("NewTextDocument") + ".txt", CreationCollisionOption.GenerateUniqueName); } TabInstance.ViewModel.AddFileOrFolder(new ListedItem(item.FolderRelativeId) { PrimaryItemAttribute = StorageItemTypes.File, ItemName = item.DisplayName, ItemDateModifiedReal = DateTimeOffset.Now, LoadUnknownTypeGlyph = true, LoadFolderGlyph = false, LoadFileIcon = false, ItemType = item.DisplayType, FileImage = null, ItemPath = item.Path, FileExtension = item.FileType }); } else if (fileType == AddItemType.BitmapImage) { StorageFile item; if (!string.IsNullOrWhiteSpace(userInput)) { item = await folderToCreateItem.CreateFileAsync(userInput + ".bmp", CreationCollisionOption.GenerateUniqueName); } else { item = await folderToCreateItem.CreateFileAsync(ResourceController.GetTranslation("NewBitmapImage") + ".bmp", CreationCollisionOption.GenerateUniqueName); } TabInstance.ViewModel.AddFileOrFolder(new ListedItem(item.FolderRelativeId) { PrimaryItemAttribute = StorageItemTypes.File, ItemName = item.DisplayName, ItemDateModifiedReal = DateTimeOffset.Now, LoadUnknownTypeGlyph = true, LoadFolderGlyph = false, LoadFileIcon = false, ItemType = item.DisplayType, FileImage = null, ItemPath = item.Path, FileExtension = item.FileType }); } }
public async Task <StorageFolder> CreateFolder(StorageFolder folder, string folderName, CreationCollisionOption colisionOptions) { StorageFolder storageFolder = await folder.CreateFolderAsync(folderName, colisionOptions); return(storageFolder); }
/// <summary> /// Folder Synchronization /// </summary> /// <param name="resourceInfo">webdav Resource to sync</param> /// <param name="folder">Target folder</param> private async Task <int> SyncFolder(ResourceInfo info, StorageFolder folder) { SyncInfoDetail sid = SyncDbUtils.GetSyncInfoDetail(info, folderSyncInfo); sid.Error = null; int changesCount = 0; try { Debug.WriteLine("Sync folder " + info.Path + ":" + folder.Path); IReadOnlyList <StorageFile> localFiles = await folder.GetFilesAsync(); IReadOnlyList <StorageFolder> localFolders = await folder.GetFoldersAsync(); List <ResourceInfo> list = null; try { list = await client.List(info.Path); } catch (ResponseError e) { ResponseErrorHandlerService.HandleException(e); } //List<Task> syncTasks = new List<Task>(); List <IStorageItem> synced = new List <IStorageItem>(); if (list != null && list.Count > 0) { foreach (ResourceInfo subInfo in list) { if (subInfo.IsDirectory) { IEnumerable <StorageFolder> localFoldersWithName = localFolders.Where(f => f.Name.Equals(subInfo.Name)); StorageFolder subFolder = localFoldersWithName.FirstOrDefault(); // Can localFoldersWithName be null? if (subFolder == null) { var subSid = SyncDbUtils.GetSyncInfoDetail(subInfo, folderSyncInfo); if (subSid != null) { Debug.WriteLine("Sync folder (delete remotely) " + subInfo.Path); if (await client.Delete(subInfo.Path)) { SyncDbUtils.DeleteSyncInfoDetail(subSid, true); } else { sid.Error = "Deletion of " + subInfo.Path + " on nextcloud failed."; // Error could be overridden by other errors } } else { // Create sid and local folder Debug.WriteLine("Sync folder (create locally) " + subInfo.Path); subFolder = await folder.CreateFolderAsync(subInfo.Name); SyncInfoDetail syncInfoDetail = new SyncInfoDetail(folderSyncInfo) { Path = subInfo.Path, FilePath = subFolder.Path }; SyncDbUtils.SaveSyncInfoDetail(syncInfoDetail); changesCount = changesCount + await SyncFolder(subInfo, subFolder); // syncTasks.Add(SyncFolder(subInfo, subFolder)); } } else { var subSid = SyncDbUtils.GetSyncInfoDetail(subInfo, folderSyncInfo); if (subSid == null) { // Both new Debug.WriteLine("Sync folder (create both) " + subInfo.Path); SyncInfoDetail syncInfoDetail = new SyncInfoDetail(folderSyncInfo) { Path = subInfo.Path, FilePath = subFolder.Path }; SyncDbUtils.SaveSyncInfoDetail(syncInfoDetail); } synced.Add(subFolder); changesCount = changesCount + await SyncFolder(subInfo, subFolder); // syncTasks.Add(SyncFolder(subInfo, subFolder)); } } else { IEnumerable <StorageFile> localFilessWithName = localFiles.Where(f => f.Name.Equals(subInfo.Name)); // Can localFilessWithName be null? StorageFile subFile = localFilessWithName.FirstOrDefault(); if (subFile != null) { synced.Add(subFile); } changesCount = changesCount + await SyncFile(subInfo, subFile, info, folder); //syncTasks.Add(SyncFile(subInfo, subFile, info, folder)); } } } foreach (StorageFile file in localFiles) { if (!synced.Contains(file)) { changesCount = changesCount + await SyncFile(null, file, info, folder); //syncTasks.Add(SyncFile(null, file, info, folder)); } } foreach (StorageFolder localFolder in localFolders) { if (!synced.Contains(localFolder)) { var subSid = SyncDbUtils.GetSyncInfoDetail(localFolder, folderSyncInfo); if (subSid != null) { // Delete all sids and local folder Debug.WriteLine("Sync folder (delete locally) " + localFolder.Path); await localFolder.DeleteAsync(); SyncDbUtils.DeleteSyncInfoDetail(subSid, true); } else { // Create sid and remotefolder string newPath = info.Path + localFolder.Name; Debug.WriteLine("Sync folder (create remotely) " + newPath); if (await client.CreateDirectory(newPath)) { ResourceInfo subInfo = await client.GetResourceInfo(info.Path, localFolder.Name); SyncInfoDetail syncInfoDetail = new SyncInfoDetail(folderSyncInfo) { Path = subInfo.Path, FilePath = localFolder.Path }; SyncDbUtils.SaveSyncInfoDetail(syncInfoDetail); changesCount = changesCount + await SyncFolder(subInfo, localFolder); //syncTasks.Add(SyncFolder(subInfo, localFolder)); } else { sid.Error = "Could not create directory on nextcloud: " + newPath; } } } } //Task.WaitAll(syncTasks.ToArray()); } catch (Exception e) { sid.Error = e.Message; } sidList.Add(sid); SyncDbUtils.SaveSyncInfoDetail(sid); SyncDbUtils.SaveSyncHistory(sid); return(changesCount); }
public static async void StartDownload(DownloadModel m, int index) { try { if (folderList == null) { await GetfolderList(); } BackgroundDownloader downloader = new BackgroundDownloader(); downloader.SetRequestHeader("Referer", "https://www.bilibili.com/blackboard/html5player.html?crossDomain=true"); downloader.SetRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36"); //设置下载模式 if (SettingHelper.DownMode == 0) { group.TransferBehavior = BackgroundTransferBehavior.Serialized; } else { group.TransferBehavior = BackgroundTransferBehavior.Parallel; } downloader.TransferGroup = group; //设置视频文件夹 StorageFolder videoFolder = null; var f = folderList.Find(x => x.id == m.folderinfo.id); if (f == null) { videoFolder = await DownFolder.CreateFolderAsync(m.folderinfo.id, CreationCollisionOption.OpenIfExists); m.folderinfo.folderPath = videoFolder.Path; m.folderinfo.thumb = await DownThumb(m.folderinfo.thumb, m.folderinfo.id, videoFolder); folderList.Add(m.folderinfo); } else { try { videoFolder = await StorageFolder.GetFolderFromPathAsync(f.folderPath); } catch (Exception ex) { MessageDialog md = new MessageDialog("Get videoFolder Error!\r\n" + ex.Message); } } //读取part文件夹 StorageFolder PartFolder = null; var partf = await videoFolder.CreateFolderAsync(m.videoinfo.mid, CreationCollisionOption.OpenIfExists); if (partf == null) { PartFolder = await videoFolder.CreateFolderAsync(m.videoinfo.mid, CreationCollisionOption.OpenIfExists); } else { PartFolder = partf; } //创建相关文件 //创建配置文件 //创建视频文件 StorageFile file = await PartFolder.CreateFileAsync(m.videoinfo.mid + "-" + index + ".flv", CreationCollisionOption.OpenIfExists); //下载弹幕文件 await DownDanMu(m.videoinfo.mid, PartFolder); DownloadOperation downloadOp = downloader.CreateDownload(new Uri(m.videoinfo.videoUrl), file); //设置下载策略 if (SettingHelper.Use4GDown) { downloadOp.CostPolicy = BackgroundTransferCostPolicy.Always; } else { downloadOp.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly; } BackgroundTransferStatus downloadStatus = downloadOp.Progress.Status; m.videoinfo.downGUID = downloadOp.Guid.ToString(); m.videoinfo.videoPath = downloadOp.ResultFile.Path; m.videoinfo.folderPath = PartFolder.Path; m.videoinfo.downstatus = false; StorageFile sefile = await PartFolder.CreateFileAsync(m.videoinfo.mid + ".json", CreationCollisionOption.OpenIfExists); await FileIO.WriteTextAsync(sefile, JsonConvert.SerializeObject(m.videoinfo)); await SetGUIDFile(m); downloadOp.StartAsync(); } catch (Exception ex) { MessageDialog md = new MessageDialog("StartDownload Eroor!\r\n" + ex.Message); await md.ShowAsync(); } finally { await SetfolderList(); await GetfolderList(); } }
private async void InitLocation() { installedLocation = await installedLocation.CreateFolderAsync("DiagramBuilder", CreationCollisionOption.OpenIfExists); }
public static async Task <StorageFolder> GetOrCreateAppFolder(string folderName) { StorageFolder localFolder = ApplicationData.Current.LocalFolder; return(await localFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists)); }
private async void MenuExport_ClickAsync(object sender, RoutedEventArgs e) { // Check and see if there are unsaved changes if (_viewModel.IsEventsModified) { await ClosePageAsync(); } DatasetExportDialog dialog = new DatasetExportDialog(_viewModel); var result = await dialog.ShowAsync(); if (result == ContentDialogResult.Primary) { StorageFolder folder = dialog.ExportFolder; DatasetExportViewModel datasetExportConfig = dialog.DatasetExportConfiguration; if (datasetExportConfig.ExportInCSV) { // Dataset exported in csv events, where metadata about the dataset is stored in json file. StorageFolder targetDatasetFolder; try { targetDatasetFolder = await folder.GetFolderAsync(datasetExportConfig.DatasetName); string message = "A folder named " + datasetExportConfig.DatasetName + " already existed at " + folder.Path + ". Do you want to overwrite?"; var dlg = new MessageDialog(message, "Overwrite Folder?"); UICommand yesCmd = new UICommand("Yes"); UICommand cancelCmd = new UICommand("Cancel"); dlg.Commands.Add(yesCmd); dlg.Commands.Add(cancelCmd); dlg.DefaultCommandIndex = 1; dlg.CancelCommandIndex = 1; var cmd = await dlg.ShowAsync(); if (cmd == cancelCmd) { return; } } catch (Exception) { } targetDatasetFolder = await folder.CreateFolderAsync(datasetExportConfig.DatasetName, CreationCollisionOption.ReplaceExisting); PageBusy(string.Format("Exporting dataset {0} to folder {1}", datasetExportConfig.DatasetName, targetDatasetFolder.Path)); if (datasetExportConfig.ExportDateSelectionEnabled) { // Copy all files foreach (var datasetFile in await _viewModel.Dataset.Folder.GetFilesAsync()) { if (datasetFile.FileType == ".csv") { List <string> eventStringList = new List <string>(); // Open file, read each line, parse the time. If the time is inbetween the start date and stop date, write the line back to file. using (var inputStream = await datasetFile.OpenReadAsync()) using (var classicStream = inputStream.AsStreamForRead()) using (var streamReader = new StreamReader(classicStream)) { int lineNo = 0; while (streamReader.Peek() >= 0) { string curEventString = streamReader.ReadLine(); if (string.IsNullOrWhiteSpace(curEventString)) { continue; } try { string [] tokenList = curEventString.Split(new char[] { ',' }); // Get the Date of the String and add to dictionary DateTimeOffset curEventTimeTag = DateTimeOffset.Parse(tokenList[0]); if (curEventTimeTag.Date >= datasetExportConfig.ExportStartDate && curEventTimeTag.Date <= datasetExportConfig.ExportStopDate) { eventStringList.Add(curEventString); } if (curEventTimeTag.Date > datasetExportConfig.ExportStopDate) { break; } lineNo++; } catch (Exception except) { Logger.Instance.Error(this.GetType().Name, string.Format("Failed at line {0} with error message {1}", lineNo, except.Message)); } } } StorageFile newDatasetFile = await targetDatasetFolder.CreateFileAsync(datasetFile.Name, CreationCollisionOption.ReplaceExisting); using (var outputStream = await newDatasetFile.OpenAsync(FileAccessMode.ReadWrite)) using (var classicStream = outputStream.AsStreamForWrite()) using (var streamWriter = new StreamWriter(classicStream)) { foreach (string eventString in eventStringList) { streamWriter.WriteLine(eventString); } } } else if (datasetFile.FileType == ".json") { await datasetFile.CopyAsync(targetDatasetFolder, datasetFile.Name, NameCollisionOption.ReplaceExisting); } } } else { // Copy all files foreach (var datasetFile in await _viewModel.Dataset.Folder.GetFilesAsync()) { await datasetFile.CopyAsync(targetDatasetFolder, datasetFile.Name, NameCollisionOption.ReplaceExisting); } } // Change name of the copied metadata file if (datasetExportConfig.DatasetRenameEnabled) { Dataset dataset = await Dataset.LoadMetadataFromFolderAsync(targetDatasetFolder); dataset.Name = datasetExportConfig.DatasetName; await dataset.WriteMetadataToFolderAsync(); } PageReady(); return; } if (datasetExportConfig.ExportInTxt) { // For backward compatibility, one can export the dataset in old-style txt format. string txtFileName = datasetExportConfig.DatasetName + "_" + DateTime.Now.ToString("yyyyMMdd_HHmmss") + ".txt"; StorageFile newDatasetFile = await folder.CreateFileAsync(txtFileName, CreationCollisionOption.ReplaceExisting); PageBusy(string.Format("Exporting dataset {0} to {1}", datasetExportConfig.DatasetName, newDatasetFile.Path)); List <string> eventStringList = new List <string>(); SensorEventViewModel sensorEvent = _viewModel.ParseSensorEventFromString(_viewModel.AllEventsStringList[0]); SensorEventViewModel nextSensorEvent; string previousActivity = ""; for (int idEvent = 0; idEvent < _viewModel.AllEventsStringList.Count; idEvent++) { nextSensorEvent = (idEvent == _viewModel.AllEventsStringList.Count - 1) ? null : _viewModel.ParseSensorEventFromString(_viewModel.AllEventsStringList[idEvent + 1]); if (sensorEvent.TimeTag.Date >= datasetExportConfig.ExportStartDate && sensorEvent.TimeTag.Date <= datasetExportConfig.ExportStopDate) { string annotationString = ""; if (sensorEvent.Activity.Name != "Other_Activity") { if (sensorEvent.Activity.Name != previousActivity) { annotationString = sensorEvent.Activity.Name + "=\"begin\""; } else if (nextSensorEvent == null) { annotationString = sensorEvent.Activity.Name + "=\"end\""; } else if (nextSensorEvent.Activity.Name != sensorEvent.Activity.Name) { annotationString = sensorEvent.Activity.Name + "=\"end\""; } } eventStringList.Add( sensorEvent.TimeTag.ToString("yyyy-MM-dd") + "\t" + sensorEvent.TimeTag.ToString("HH:mm:ss.ffffff") + "\t" + sensorEvent.Sensor.Name + "\t" + sensorEvent.SensorState + "\t" + annotationString ); previousActivity = sensorEvent.Activity.Name; } if (sensorEvent.TimeTag.Date > datasetExportConfig.ExportStopDate) { break; } sensorEvent = nextSensorEvent; } using (var outputStream = await newDatasetFile.OpenAsync(FileAccessMode.ReadWrite)) using (var classicStream = outputStream.AsStreamForWrite()) using (var streamWriter = new StreamWriter(classicStream)) { foreach (string eventString in eventStringList) { streamWriter.WriteLine(eventString); } } PageReady(); return; } } }
private async Task DownloadFile(SkyDriveListItem item, LiveConnectClient client) { StorageFolder folder = ApplicationData.Current.LocalFolder; StorageFolder romFolder = await folder.CreateFolderAsync(FileHandler.ROM_DIRECTORY, CreationCollisionOption.OpenIfExists); StorageFolder saveFolder = await romFolder.CreateFolderAsync(FileHandler.SAVE_DIRECTORY, CreationCollisionOption.OpenIfExists); String path = romFolder.Path; String savePath = saveFolder.Path; ROMDatabase db = ROMDatabase.Current; var indicator = SystemTray.GetProgressIndicator(this); indicator.IsIndeterminate = true; indicator.Text = String.Format(AppResources.DownloadingProgressText, item.Name); LiveDownloadOperationResult e = await client.DownloadAsync(item.SkyDriveID + "/content"); if (e != null) { byte[] tmpBuf = new byte[e.Stream.Length]; StorageFile destinationFile = null; ROMDBEntry entry = null; if (item.Type == SkyDriveItemType.SRAM) { entry = db.GetROMFromSRAMName(item.Name); if (entry != null) { destinationFile = await saveFolder.CreateFileAsync(Path.GetFileNameWithoutExtension(entry.FileName) + ".sav", CreationCollisionOption.ReplaceExisting); } else { destinationFile = await saveFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); } } else if (item.Type == SkyDriveItemType.Savestate) { entry = db.GetROMFromSavestateName(item.Name); if (entry != null) { destinationFile = await saveFolder.CreateFileAsync(Path.GetFileNameWithoutExtension(entry.FileName) + item.Name.Substring(item.Name.Length - 5), CreationCollisionOption.ReplaceExisting); } else { destinationFile = await saveFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); } } using (IRandomAccessStream destStream = await destinationFile.OpenAsync(FileAccessMode.ReadWrite)) using (DataWriter writer = new DataWriter(destStream)) { while (e.Stream.Read(tmpBuf, 0, tmpBuf.Length) != 0) { writer.WriteBytes(tmpBuf); } await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); } e.Stream.Close(); item.Downloading = false; if (item.Type == SkyDriveItemType.Savestate) { String number = item.Name.Substring(item.Name.Length - 5, 1); int slot = int.Parse(number); if (entry != null) //NULL = do nothing { SavestateEntry saveentry = db.SavestateEntryExisting(entry.FileName, slot); if (saveentry != null) { //delete entry db.RemoveSavestateFromDB(saveentry); } SavestateEntry ssEntry = new SavestateEntry() { ROM = entry, Savetime = DateTime.Now, Slot = slot, FileName = item.Name }; db.Add(ssEntry); db.CommitChanges(); } } MessageBox.Show(String.Format(AppResources.DownloadCompleteText, item.Name)); } else { MessageBox.Show(String.Format(AppResources.DownloadErrorText, item.Name, "Api error"), AppResources.ErrorCaption, MessageBoxButton.OK); } #if GBC indicator.Text = AppResources.ApplicationTitle2; #else indicator.Text = AppResources.ApplicationTitle; #endif indicator.IsIndeterminate = false; }
private async void savedata() { var dataFolder = await local.CreateFolderAsync("StarData", CreationCollisionOption.OpenIfExists); var file = await dataFolder.CreateFileAsync("ImageStar", CreationCollisionOption.OpenIfExists); }
/// <summary> /// Maakt voor elk aangemaakt pdf bestand een nieuwe map met hierin alle pagina's apart per afbeelding. /// </summary> /// <param name="renderOption"></param> /// <param name="bestanden">Een lijst met StorageFolders instanties</param> /// <returns>Eventueel de lijst van StorageFiles indien nodig</returns> public async Task <List <StorageFile> > GetAfbeeldingenVanPDF(RENDEROPTIONS renderOption, List <StorageFile> bestanden) { List <StorageFile> paginas = new List <StorageFile>(); //Bekomen lijst van PDF pagina als afbeelding foreach (StorageFile bestand in bestanden) { string bestandsNaam = bestand.Name.Replace(".pdf", ""); //PDF extensie uit de naam wissen voor de folder try { await doelfolder.CreateFolderAsync(bestandsNaam, CreationCollisionOption.ReplaceExisting); //Maak de doelfolder aan en vervang indien nodig //PDF bestand laden PdfDocument _pdfDocument = await PdfDocument.LoadFromFileAsync(bestand);; if (_pdfDocument != null && _pdfDocument.PageCount > 0) { // next, generate a bitmap of the page StorageFolder tempFolder = ApplicationData.Current.TemporaryFolder; for (uint pagina = 0; pagina < _pdfDocument.PageCount; pagina++) { var pdfPage = _pdfDocument.GetPage(pagina); if (pdfPage != null) { StorageFile jpgFile = await doelfolder. CreateFileAsync(String.Format("\\{0}\\{1}_pagina{2}.png", bestandsNaam, bestandsNaam, pagina), CreationCollisionOption.ReplaceExisting); if (jpgFile != null) { IRandomAccessStream randomStream = await jpgFile.OpenAsync(FileAccessMode.ReadWrite); PdfPageRenderOptions pdfPageRenderOptions = new PdfPageRenderOptions(); switch (renderOption) { case RENDEROPTIONS.NORMAL: //PDF pagina inladen await pdfPage.RenderToStreamAsync(randomStream); break; case RENDEROPTIONS.ZOOM: //set PDFPageRenderOptions.DestinationWidth or DestinationHeight with expected zoom value Size pdfPageSize = pdfPage.Size; pdfPageRenderOptions.DestinationHeight = (uint)pdfPageSize.Height * ZOOM_FACTOR; //Render pdf page at a zoom level by passing pdfpageRenderOptions with DestinationLength set to the zoomed in length await pdfPage.RenderToStreamAsync(randomStream, pdfPageRenderOptions); break; } await randomStream.FlushAsync(); randomStream.Dispose(); pdfPage.Dispose(); paginas.Add(jpgFile); } } } } } catch (Exception e) { paLogging.log.Error(String.Format("Er is een fout opgetreden bij het converteren van pdf {0} naar afbeeldingen: {1}", bestandsNaam, e.Message)); } } return(paginas); //Pagina's teruggeven (leeg indien exception, e.d.) }
// ----------------------------------------------------------------------- // Button Dropbox // ----------------------------------------------------------------------- private async void Dropbox_PointerReleased(object sender, PointerRoutedEventArgs e) { // Antwort string answer = ""; string name = ""; // Schleife bis Daten vorhanden while (answer != resource.GetString("001_Abbrechen")) { // Passwort Eingabe erstellen DialogEx dEx = new DialogEx(resource.GetString("001_Einstellungen")); DialogExTextBox tbUser = new DialogExTextBox(resource.GetString("001_Name"), name); dEx.AddTextBox(tbUser); DialogExButtonsSet btnSet = new DialogExButtonsSet(); btnSet.Margin = new Thickness(0, 6, 0, 24); DialogExButton btnAbort = new DialogExButton(resource.GetString("001_Abbrechen")); btnSet.AddButton(btnAbort); DialogExButton btnCheck = new DialogExButton(resource.GetString("001_Hinzufügen")); btnSet.AddButton(btnCheck); dEx.AddButtonSet(btnSet); await dEx.ShowAsync(grMain); // Daten auslesen answer = dEx.GetAnswer(); name = dEx.GetTextBoxTextByTitle(resource.GetString("001_Name")); // Wenn Antwort Hinzufügen if (answer == resource.GetString("001_Hinzufügen")) { // Wenn kein Dropbox Name vorhanden if (dEx.GetTextBoxTextByIndex(0) == "") { // Nachricht ausgeben // Kein Name eingegeben dEx = new DialogEx(resource.GetString("001_KeinName")); DialogExButtonsSet dBSet = new DialogExButtonsSet(); DialogExButton dBtn = new DialogExButton(resource.GetString("001_Schließen")); dBSet.AddButton(dBtn); dEx.AddButtonSet(dBSet); await dEx.ShowAsync(grMain); } // Wenn ein Name eingegeben else { // Semikolon entfernen name = Regex.Replace(name, ";", ""); // Versuchen einen Ordner zu erstellen try { // Ordner erstellen StorageFolder sf = await folderTemp.CreateFolderAsync(name); await sf.DeleteAsync(); // Dropbox verbinden dropboxToken = ""; dropboxToken = await DropboxConnect(); // Wenn Token vorhanden if (dropboxToken != "") { // One Drive in Start hinzufügen MainPage.setStartMenu += "dropbox;" + name + ";" + dropboxToken + ";;;"; // Einstellungen speichern StorageFile storageFile = await folderSettings.CreateFileAsync("StartMenu.txt", CreationCollisionOption.OpenIfExists); await FileIO.WriteTextAsync(storageFile, MainPage.setStartMenu); // Zurück zur Startseite Frame.GoBack(); // Schleife beenden break; } // Bei Fehlern else { // Nachricht ausgeben // Verbindung nicht möglich dEx = new DialogEx(resource.GetString("001_VerbindungNicht")); DialogExButtonsSet dBSet = new DialogExButtonsSet(); DialogExButton dBtn = new DialogExButton(resource.GetString("001_Schließen")); dBSet.AddButton(dBtn); dEx.AddButtonSet(dBSet); await dEx.ShowAsync(grMain); } } // Wenn Name nicht verwendet werden kann catch { // Nachricht ausgeben // Kein Name eingegeben dEx = new DialogEx(resource.GetString("001_NameFalsch")); DialogExButtonsSet dBSet = new DialogExButtonsSet(); DialogExButton dBtn = new DialogExButton(resource.GetString("001_Schließen")); dBSet.AddButton(dBtn); dEx.AddButtonSet(dBSet); await dEx.ShowAsync(grMain); } } } } }
private async void IntializeChakraAndExecute(string function_name) { /* * ============================= * = ADDONS EXECUTOR VARIABLES = * ============================= */ host.Chakra.ProjectObjectToGlobal(_SCEELibs, "sceelibs"); /* * =========================== * = ADDONS EXECUTOR CONTENT = * =========================== */ InfosModule ModuleAccess = AsyncHelpers.RunSync(async() => await ModulesAccessManager.GetModuleViaIDAsync(_id)); StorageFolder folder_module; if (ModuleAccess.ModuleSystem) { StorageFolder folder_content = AsyncHelpers.RunSync(async() => await Package.Current.InstalledLocation.GetFolderAsync("SerrisModulesServer")), folder_systemmodules = AsyncHelpers.RunSync(async() => await folder_content.GetFolderAsync("SystemModules")); folder_module = AsyncHelpers.RunSync(async() => await folder_systemmodules.CreateFolderAsync(_id + "", CreationCollisionOption.OpenIfExists)); } else { StorageFolder folder_content = AsyncHelpers.RunSync(async() => await ApplicationData.Current.LocalFolder.CreateFolderAsync("modules", CreationCollisionOption.OpenIfExists)); folder_module = AsyncHelpers.RunSync(async() => await folder_content.CreateFolderAsync(_id + "", CreationCollisionOption.OpenIfExists)); } foreach (string path in ModuleAccess.JSFilesPathList) { StorageFolder _folder_temp = folder_module; StorageFile _file_read = AsyncHelpers.RunSync(async() => await folder_module.GetFileAsync("main.js")); bool file_found = false; string path_temp = path; while (!file_found) { if (path_temp.Contains(Path.AltDirectorySeparatorChar)) { //Debug.WriteLine(path_temp.Split(Path.AltDirectorySeparatorChar).First()); _folder_temp = AsyncHelpers.RunSync(async() => await _folder_temp.GetFolderAsync(path_temp.Split(Path.AltDirectorySeparatorChar).First())); path_temp = path_temp.Substring(path_temp.Split(Path.AltDirectorySeparatorChar).First().Length + 1); } else { _file_read = AsyncHelpers.RunSync(async() => await _folder_temp.GetFileAsync(path_temp)); file_found = true; break; } } try { using (StreamReader reader = AsyncHelpers.RunSync(async() => new StreamReader(await _file_read.OpenStreamForReadAsync()))) { host.Chakra.RunScript(AsyncHelpers.RunSync(async() => await reader.ReadToEndAsync())); } } catch { Debug.WriteLine("Erreur ! :("); } } StorageFile main_js = AsyncHelpers.RunSync(async() => await folder_module.GetFileAsync("main.js")); try { string code = AsyncHelpers.RunSync(async() => await FileIO.ReadTextAsync(main_js)); host.Chakra.RunScript(code); } catch (Exception ex) { Debug.WriteLine(ex.Message); } try { host.Chakra.CallFunction(function_name); } catch { } }