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);
}
