public async void DeleteButton_Clicked(object sender, EventArgs e) { ExistenceCheckResult res = await rootFolder.CheckExistsAsync("name.txt"); if (res == ExistenceCheckResult.FileExists) { IFile file = await rootFolder.GetFileAsync("name.txt"); await file.DeleteAsync(); //loadedLabel.Text = ""; } }
public async static Task <bool> IsFileExistAsync(this string fileName, IFolder rootFolder = null) { // get hold of the file system IFolder folder = rootFolder ?? FileSystem.Current.LocalStorage; ExistenceCheckResult folderexist = await folder.CheckExistsAsync(fileName); // already run at least once, don't overwrite what's there if (folderexist == ExistenceCheckResult.FileExists) { return(true); } return(false); }
// Metodo que verifica se existe uma pasta public async static Task <bool> ExistePastaAsync(string nomePasta, IFolder pastaRoot = null) { // Acessar o sistema de arquivos Root IFolder pasta = pastaRoot ?? FileSystem.Current.LocalStorage; ExistenceCheckResult pastaExiste = await pasta.CheckExistsAsync(nomePasta); // Verifica se existe a pasta if (pastaExiste == ExistenceCheckResult.FolderExists) { return(true); } return(false); }
public async void SetPublicationImage(string img) { IFolder rootfolder = FileSystem.Current.LocalStorage; ExistenceCheckResult exist = await rootfolder.CheckExistsAsync(img); if (exist == ExistenceCheckResult.FileExists) { _publicationImage = Path.Combine(FileSystem.Current.LocalStorage.Path, img); } else { _publicationImage = Path.Combine(FileSystem.Current.LocalStorage.Path, "Icon.jpg"); } }
public async Task <string> ReadFromFile() { //Todo - check if file exists..if not then create one IFolder rootFolder = FileSystem.Current.LocalStorage; IFolder folder = await rootFolder.CreateFolderAsync("AppContent", CreationCollisionOption.OpenIfExists); ExistenceCheckResult isFileExisting = await folder.CheckExistsAsync("Budget.txt"); IFile file = await folder.CreateFileAsync("Budget.txt", CreationCollisionOption.OpenIfExists); var rtrt = file.ReadAllTextAsync(); return(await file.ReadAllTextAsync()); }
public async static Task <bool> FolderExists(string foldername) { IFolder folder = FileSystem.Current.LocalStorage; ExistenceCheckResult folderCheckResult = await folder.CheckExistsAsync(foldername); if (folderCheckResult == ExistenceCheckResult.FolderExists) { return(true); } else { return(false); } }
private async void LoadClicked(object sender, EventArgs e) { ExistenceCheckResult res = await rootFolder.CheckExistsAsync("name.txt"); if (res == ExistenceCheckResult.FileExists) { IFile file = await rootFolder.GetFileAsync("name.txt"); string name = await file.ReadAllTextAsync(); loadedLabel.Text = name; } else { await DisplayAlert("Error", "File is not found", "OK"); } }
public static async Task <string> ReadFileContent(string fileName, IFolder rootFolder) { ExistenceCheckResult exist = await rootFolder.CheckExistsAsync(fileName); string text = null; if (exist == ExistenceCheckResult.FileExists) { IFile file = await rootFolder.GetFileAsync(fileName); text = await file.ReadAllTextAsync(); } return(text); }
public async static void RemoveAllData() { IFolder rootFolder = FileSystem.Current.LocalStorage; ExistenceCheckResult kuchaFolderExists = await rootFolder.CheckExistsAsync("Kucha"); if (kuchaFolderExists == ExistenceCheckResult.FolderExists) { IFolder kuchaFolder = await rootFolder.GetFolderAsync("Kucha"); await kuchaFolder.DeleteAsync(); kuchaContainer = null; App.Current.MainPage = new UI.LoginPage(); } }
public static async Task Import(int parentId) { await CheckInitialized(); string[] types = { ".zip" }; FileData zipFile = await CrossFilePicker.Current.PickFile(types); if (zipFile == null) { return; } IFile newZip = await CopyZip(zipFile.FileName, zipFile.DataArray); Tuple <string, string> values = await Unzip(newZip.Path); IFolder import = await RootDir.GetFolderAsync(values.Item1); IFile json = await import.GetFileAsync("content.json"); string jsonText = await json.ReadAllTextAsync(); Book b = JsonToBook(jsonText); Debug.WriteLine($"NewBook: {b.ToString()}"); RealmManager.ImportBook(b, parentId); IFile old; foreach (Entry e in b.Entries) { string[] splits = e.ImagePath.Split('_'); string oldPath = $"{b.Id}_{splits[1]}"; ExistenceCheckResult exists = await import.CheckExistsAsync(oldPath); if (exists == ExistenceCheckResult.NotFound) { Debug.WriteLine($"Image not Found at: {e.ImagePath}"); continue; } old = await import.GetFileAsync(oldPath); await old.MoveAsync($"{ImageDir.Path}\\{old.Name}", NameCollisionOption.ReplaceExisting); } await import.DeleteAsync(); await newZip.DeleteAsync(); }
/// <summary> /// Returns the embedded file from the device's storage if it exists, else returns a new embedded file created from a source file. /// </summary> /// <returns>The embedded file containing current features</returns> public async Task <IFile> GetEmbeddedFile() { IFolder rootFolder = FileSystem.Current.LocalStorage; rootFolder.Path.Replace("/../Library", " "); ExistenceCheckResult embeddedFileExists = await rootFolder.CheckExistsAsync(EMBEDDED_FILENAME); // If DEBUG bool set to true, will delete the embedded file and create a new one from the source path. if (DEBUG_DELETE_EMBEDDED_FILE) { DEBUG_DELETE_EMBEDDED_FILE = false; if (embeddedFileExists == ExistenceCheckResult.FileExists) { IFile file = await rootFolder.GetFileAsync(EMBEDDED_FILENAME); await file.DeleteAsync(); Debug.WriteLine("\n\n:::::::::::::::::::DELETE SUCCESSFUL (Turn off this bool in the next build to re-enable persistent storage)"); embeddedFileExists = ExistenceCheckResult.NotFound; } } // Attempt to open the embedded file on the device. // If it exists return it, else create a new embedded file from a json source file. if (embeddedFileExists == ExistenceCheckResult.FileExists) { return(await rootFolder.GetFileAsync(EMBEDDED_FILENAME)); } else { var assembly = IntrospectionExtensions.GetTypeInfo(this.GetType()).Assembly; Stream stream = assembly.GetManifestResourceStream(EMBEDDED_FILE_SOURCE_PATH); string json; using (var reader = new System.IO.StreamReader(stream)) { json = reader.ReadToEnd(); } IFile featuresFile = await rootFolder.CreateFileAsync(EMBEDDED_FILENAME, CreationCollisionOption.ReplaceExisting); await featuresFile.WriteAllTextAsync(json); return(featuresFile); } }
private async void ReceiveSurveys() { SurveysServices S_S1 = new SurveysServices(); ControlFile controlFile = new ControlFile(); string username = await controlFile.GetUserName(); S_S1.Set_UrlApi("ReceiveSurveysShared/" + username); List <Survey> ReceivedSurveys = await S_S1.GetSurveysAsync(); ExistenceCheckResult result = await folder.CheckExistsAsync("Receivedsurveys"); if (result == ExistenceCheckResult.FolderExists) { folder = await folder.CreateFolderAsync("Receivedsurveys", CreationCollisionOption.OpenIfExists); file = await folder.CreateFileAsync("Receivedsurveys", CreationCollisionOption.OpenIfExists); string Content = await file.ReadAllTextAsync(); List <Survey> OldreceiveSurveys = Serializable_Survey.deserialize(Content).ToList(); if (OldreceiveSurveys.Count < ReceivedSurveys.Count) { var player = Plugin.SimpleAudioPlayer.CrossSimpleAudioPlayer.Current; player.Load("NotificationReceive.mp3"); player.Play(); Plugin.LocalNotifications.CrossLocalNotifications.Current.Show(Lang.Resource.receivesurveys, Lang.Resource.BodyreceiveSurvey, 0); } } else if (result != ExistenceCheckResult.FolderExists && ReceivedSurveys.Count > 0) { var player = Plugin.SimpleAudioPlayer.CrossSimpleAudioPlayer.Current; player.Load("NotificationReceive.mp3"); player.Play(); Plugin.LocalNotifications.CrossLocalNotifications.Current.Show(Lang.Resource.receivesurveys, Lang.Resource.BodyreceiveSurvey, 0); } folder = FileSystem.Current.LocalStorage; folder = await folder.CreateFolderAsync("Receivedsurveys", CreationCollisionOption.ReplaceExisting); file = await folder.CreateFileAsync("Receivedsurveys", CreationCollisionOption.ReplaceExisting); string content = Serializable_Survey.serialize(ReceivedSurveys); await file.WriteAllTextAsync(content); }
async void DownloadPhotos() { DependencyService.Get <IDownloader>().Show("Descargando"); var response = await apiService.GetEficienciaBihorarioBloque <EficienciaBihorario>(user.cbloqu); if (!response.IsSuccess) { await dialogService.ShowMessage("Aviso", response.Message); DependencyService.Get <IDownloader>().Hide(); return; } var fichas = (List <EficienciaBihorario>)response.Result; // dataGrid.ItemsSource = fichas; //********** INICIO DESCARGA DE ARCHIVOS DESDE FTP **********// foreach (var recordf in fichas) { string xctraba = ""; if (Int32.Parse(recordf.ctraba.Substring(1, 5)) > 10000) { xctraba = recordf.ctraba; } else { xctraba = recordf.ctraba.Substring(0, 1) + recordf.ctraba.Substring(2, 4); } IFolder rootFolder = await FileSystem.Current.GetFolderFromPathAsync("/storage/emulated/0/Fotos/"); ExistenceCheckResult folderexist = await rootFolder.CheckExistsAsync(xctraba); if (folderexist == ExistenceCheckResult.FileExists) { IFile file = await rootFolder.GetFileAsync(xctraba + ".bmp"); await file.DeleteAsync(); } string rutapdf = "ftp://192.168.2.55:22/" + xctraba + ".bmp"; downloader.DownloadFile(rutapdf, "Fotos"); } DependencyService.Get <IDownloader>().Hide(); //********** FIN DESCARGA DE ARCHIVOS DESDE FTP **********// }
public SQLiteConnection CreateConnection() { IFolder rootFolder = FileSystem.Current.LocalStorage; ExistenceCheckResult result = AsyncHelpers.RunSync(() => rootFolder.CheckExistsAsync(databaseFileName)); if (result == ExistenceCheckResult.NotFound) { IFile file = AsyncHelpers.RunSync(() => rootFolder.CreateFileAsync(databaseFileName, CreationCollisionOption.ReplaceExisting)); SQLiteConnection connection = new SQLiteConnection(file.Path); connection.CreateTable <Item>(); return(connection); } else { IFile file = AsyncHelpers.RunSync(() => rootFolder.CreateFileAsync(databaseFileName, CreationCollisionOption.OpenIfExists)); return(new SQLiteConnection(file.Path)); } }
private void LoadFromDisk(List <EntryType> list) { list.Clear(); IFolder rootFolder = FileSystem.Current.LocalStorage; ExistenceCheckResult result = rootFolder.CheckExistsAsync("db.txt").Result; if (result == ExistenceCheckResult.FileExists) { IFile file = rootFolder.GetFileAsync("db.txt").Result; string content = file.ReadAllTextAsync().Result; if (!string.IsNullOrEmpty(content)) { list.AddRange(JsonConvert.DeserializeObject <List <EntryType> >(content)); } } }
public async static Task <IFolder> GetFolder(this string folderName, IFolder rootFolder = null) { // get hold of the file system IFolder rtFolder = rootFolder ?? FileSystem.Current.LocalStorage; ExistenceCheckResult folderexist = await rtFolder.CheckExistsAsync(folderName); IFolder folder; if (folderexist == ExistenceCheckResult.FolderExists) { folder = await rtFolder.GetFolderAsync(folderName); } else { folder = await rtFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists); } return(folder); }
private static async Task <string> Zip(string sourcePath, string bookTitle) { await CheckInitialized(); ExistenceCheckResult exists = await RootDir.CheckExistsAsync($"{bookTitle}.zip"); if (exists == ExistenceCheckResult.FileExists) { IFile temp = await RootDir.GetFileAsync($"{bookTitle}.zip"); await temp.DeleteAsync(); } string targetPath = RootDir.Path + $"\\{bookTitle}.zip"; ZipFile.CreateFromDirectory(sourcePath, targetPath); return(targetPath); }
/// <summary> /// ユーザーデータをファイルから読み取る /// </summary> /// <returns></returns> static private async Task <string> LoadTextAsync() { // ユーザーデータ保存フォルダー PCLStorage.IFolder localFolder = PCLStorage.FileSystem.Current.LocalStorage; ExistenceCheckResult res = await localFolder.CheckExistsAsync(TextFileName).ConfigureAwait(false); if (res == ExistenceCheckResult.NotFound) { return(null); } // ファイルを取得する PCLStorage.IFile file = await localFolder.GetFileAsync(TextFileName).ConfigureAwait(false); // テキストファイルを読み込む return(await file.ReadAllTextAsync().ConfigureAwait(false)); }
/// <summary> /// Adds <see cref="ChiamataLibrary.GameData"/> to the archive from the XML files found in the specified folder. /// </summary> /// <param name="path">The path of the XML files.</param> private void AddFromFolder() { int c = 0; IFolder folder = GetFolder(); ExistenceCheckResult exist = folder.CheckExistsAsync(GetFileName(c)).Result; while (exist == ExistenceCheckResult.FileExists) { IFile file = folder.GetFileAsync(GetFileName(c)).Result; using (Stream s = file.OpenAsync(FileAccess.Read).Result) Add(new GameData(s)); ++c; exist = folder.CheckExistsAsync(GetFileName(c)).Result; } }
public static async Task <Dictionary <IFolder, string> > GetAllDirectoriesAsync(OGLContext context, string type) { Dictionary <IFolder, string> result = new Dictionary <IFolder, string>(); foreach (IFolder s in Sources) { if (context.ExcludedSources.Contains(s.Name, StringComparer.OrdinalIgnoreCase)) { continue; } ExistenceCheckResult res = await s.CheckExistsAsync(type); if (res == ExistenceCheckResult.FolderExists) { result.Add(await s.GetFolderAsync(type), s.Name); } } return(result); }
private async Task loadTokenAsync() { AuthToken = null; ExistenceCheckResult res = await loginFolder.CheckExistsAsync(CURRENT_TOKEN_FILE); if (res.Equals(ExistenceCheckResult.FileExists)) { IFile file = await loginFolder.GetFileAsync(CURRENT_TOKEN_FILE); string json = await file.ReadAllTextAsync(); AuthToken = JsonConvert.DeserializeObject <AuthToken>(json); if (AuthToken != null) { IsLoggedIn = true; } NotifyTokenChanged(); } }
/// <summary> /// Reads content from a file /// </summary> /// <param name="filename">the name of the file</param> /// <param name="foldername">the name of the folder containing the file</param> /// <returns>string of the read content</returns> public static async Task <string> ReadFileContent(string filename, string foldername) { var rootFolder = FileSystem.Current.LocalStorage; IFolder specificFolder = await rootFolder.CreateFolderAsync(foldername, CreationCollisionOption.OpenIfExists); await specificFolder.CreateFileAsync(filename, CreationCollisionOption.OpenIfExists); ExistenceCheckResult exist = await specificFolder.CheckExistsAsync(filename); string text = null; if (exist == ExistenceCheckResult.FileExists) { IFile file = await specificFolder.GetFileAsync(filename); text = await file.ReadAllTextAsync(); } return(text); }
public async Task ReadCSVFile() { IFolder rootFolder = FileSystem.Current.LocalStorage; try { string filename = "Logs.csv"; IFile file = await rootFolder.CreateFileAsync(filename, CreationCollisionOption.FailIfExists); await file.ReadAllTextAsync(); } catch (Exception ex) { Debug.WriteLine("Error message: ", ex.Message); } ExistenceCheckResult exist = await rootFolder.CheckExistsAsync("Logs.csv"); }
private async void HandleConnectivityChanged(object sender, ConnectivityChangedEventArgs e) { if (e.IsConnected) { string Content; // Post Responsed Surveys folder = FileSystem.Current.LocalStorage; List <Survey> surveys = new List <Survey>(); ExistenceCheckResult result = await folder.CheckExistsAsync("ShareResponsedSurveys"); if (result == ExistenceCheckResult.FolderExists) { folder = await folder.CreateFolderAsync("ShareResponsedSurveys", CreationCollisionOption.OpenIfExists); file = await folder.CreateFileAsync("ShareResponsedSurveys", CreationCollisionOption.OpenIfExists); Content = await file.ReadAllTextAsync(); if (String.IsNullOrEmpty(Content) || String.IsNullOrWhiteSpace(Content)) { return; } surveys = Serializable_Survey.deserialize(Content).ToList(); foreach (Survey S in surveys) { SurveysServices S_S = new SurveysServices(); S_S.Set_UrlApi("ShareResponsedSurveys/"); await S_S.PostSurveysAsync(S); } folder = FileSystem.Current.LocalStorage; folder = await folder.GetFolderAsync("ShareResponsedSurveys"); await folder.DeleteAsync(); } // Receive Surveys ReceiveSurveys(); // Receive Responsed Surveys ReceiveResponsedSurveys(); } }
public async Task <bool> GetGameExists() { IFolder folder = FileSystem.Current.LocalStorage; ExistenceCheckResult fileExists = await folder.CheckExistsAsync(GAME_STATE_FILENAME); if (fileExists == ExistenceCheckResult.FileExists) { IFile file = await folder.GetFileAsync(GAME_STATE_FILENAME); var serializedGame = await file.ReadAllTextAsync(); if (serializedGame == null || serializedGame == "null") { await DeleteGame(); return(false); } return(true); } return(false); }
protected override void OnAppearing() { base.OnAppearing(); Device.BeginInvokeOnMainThread(async() => { IFolder folder = FileSystem.Current.LocalStorage; String folderName = "receipt"; ExistenceCheckResult exist = await folder.CheckExistsAsync(folderName); //String filename = "username.txt"; //IFile file = await folder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); if (exist == ExistenceCheckResult.FolderExists) { //await DisplayAlert("Alert",folderName+" is exist","OK"); IList <IFile> files = await folder.GetFilesAsync(); //await DisplayAlert("Alert", files.Count + " number of files", "OK"); pdfListView.ItemsSource = files; } }); }
private static async Task <IFile> GetDataFileAsync(string fileName) { IFolder rootFolder = FileSystem.Current.LocalStorage; IFolder folder = rootFolder ?? FileSystem.Current.LocalStorage; ExistenceCheckResult dataFolderExists = await folder.CheckExistsAsync(VariablesGlobal.NAME_FOLDER_DATA); if (dataFolderExists == ExistenceCheckResult.FolderExists) { IFolder dataFolder = await rootFolder.GetFolderAsync(VariablesGlobal.NAME_FOLDER_DATA); ExistenceCheckResult fileExists = await dataFolder.CheckExistsAsync(fileName); if (fileExists == ExistenceCheckResult.FileExists) { return(await dataFolder.GetFileAsync(fileName)); } } return(null); }
public static async Task <bool> IsFileExistAsync(string fileName) { // get hold of the file system try { IFolder folder = await FileSystem.Current.LocalStorage.GetFolderAsync(folderName); ExistenceCheckResult folderexist = await folder.CheckExistsAsync(fileName); // already run at least once, don't overwrite what's there if (folderexist == ExistenceCheckResult.FileExists) { return(true); } return(false); } catch (Exception) { return(false); } }
protected async override void OnStart() { try { ExistenceCheckResult profileExists = ExistenceCheckResult.NotFound; var rootFolder = FileSystem.Current.LocalStorage; switch (Xamarin.Forms.Device.RuntimePlatform) { case "Android": { profileExists = rootFolder.CheckExistsAsync("profile").Result; break; } case "Windows": { profileExists = await rootFolder.CheckExistsAsync("profile"); break; } } Page destinationPage = null; if (profileExists == ExistenceCheckResult.FileExists) { destinationPage = new MainPage(); } else { destinationPage = new RegisterPage(); } await this.MainPage.Navigation.PushAsync(destinationPage); } catch (Exception ex) { } }
public static async Task <bool> IsFileExistAsync(this string folderFileName, string rootFolderName = null) { IFolder folder = null; if (rootFolderName == null) { folder = FileSystem.Current.LocalStorage; } else { folder = await FileSystem.Current.LocalStorage.CreateFolderAsync(rootFolderName, CreationCollisionOption.OpenIfExists); } ExistenceCheckResult folderexist = await folder.CheckExistsAsync(folderFileName); // already run at least once, don't overwrite what's there if (folderexist == ExistenceCheckResult.FileExists) { return(true); } return(false); }