|
private CreateFileAsync ( [ desiredName ) : IAsyncOperation |
||
| desiredName | [ | |
| return | IAsyncOperation |
|
public static async Task ClearData()
{
Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
StorageFile sampleFile_times_ms = await localFolder.CreateFileAsync(StorageRepos.times_ms,
CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(sampleFile_times_ms, "");
StorageFile sampleFile_times_sm = await localFolder.CreateFileAsync(StorageRepos.times_sm,
CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(sampleFile_times_sm, "");
StorageFile sampleFile_stations_ms = await localFolder.CreateFileAsync(StorageRepos.stations_ms,
CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(sampleFile_stations_ms, "");
StorageFile sampleFile_stations_sm = await localFolder.CreateFileAsync(StorageRepos.stations_sm,
CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(sampleFile_stations_sm, "");
//ApplicationData.Current.RoamingSettings.Values[StorageRepos.LastUpdateAt] = DateTime.Now;
}
public async static void CreateEventFile()
{
Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
await localFolder.CreateFileAsync("events.xml");
StorageFile sampleFile = await localFolder.CreateFileAsync("events.xml", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(sampleFile, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n <events>\n </events>\n");
}
//Initialize the new Crypto object (initialized only once per app startup)
public async void initCrypto()
{
this.strAsymmetricAlgName = AsymmetricAlgorithmNames.RsaPkcs1;
this.asymmetricKeyLength = 512;
//Checks SecureChat's folder if a key pair already exists and set keyPairExists boolean
Windows.Storage.StorageFolder localAppFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
string cryptoFilePrivate = "SecureChatPrivateKeys.sckey"; //STORED AS BYTE DATA
string cryptoFilePublic = "SecureChatPublicKey.sckey"; //STORED AS TEXT DATA
if ((await localAppFolder.TryGetItemAsync(cryptoFilePublic) != null) && (await localAppFolder.TryGetItemAsync(cryptoFilePrivate) != null))
{
this.keyPairExists = true;
}
else
{
this.keyPairExists = false;
}
//Load Keys depending on keyPairExists value
if (this.keyPairExists == true)
{
//DIRECT IBUFFER
//StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync(cryptoFilePublic);
//this.buffPublicKey = await FileIO.ReadBufferAsync(loadedCryptoFilePublic);
//FROM BYTE
//StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync("BytePubKey.sckey");
//this.buffPublicKey = await FileIO.ReadBufferAsync(loadedCryptoFilePublic);
//Open Public Key File. Convert key from STRING to BYTE and then convert to IBUFFER
StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync(cryptoFilePublic);
String publicKeyStringVersion = await FileIO.ReadTextAsync(loadedCryptoFilePublic);
this.publicKeyByteVersion = Convert.FromBase64String(publicKeyStringVersion);
this.buffPublicKey = this.publicKeyByteVersion.AsBuffer();
//Open Private Key File
StorageFile loadedCryptoFilePrivate = await localAppFolder.GetFileAsync(cryptoFilePrivate);
this.buffPrivateKeyStorage = await FileIO.ReadBufferAsync(loadedCryptoFilePrivate);
}
else
{
//Generate new key pair
CryptographicKey temp = this.CreateAsymmetricKeyPair(strAsymmetricAlgName, asymmetricKeyLength, out buffPublicKey, out buffPrivateKeyStorage);
//Convert public key from IBUFFER type to BYTE type. Convert from BYTE type to STRING type
WindowsRuntimeBufferExtensions.CopyTo(this.buffPublicKey, this.publicKeyByteVersion);
string publicKeyStringVersion = Convert.ToBase64String(this.publicKeyByteVersion);
//Store keys in appropriate files (Public as PLAIN TEXT, Private as IBUFFER)
await FileIO.WriteTextAsync((await localAppFolder.CreateFileAsync(cryptoFilePublic)), publicKeyStringVersion);
await FileIO.WriteBufferAsync((await localAppFolder.CreateFileAsync(cryptoFilePrivate)), this.buffPrivateKeyStorage);
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
//Select problem button
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile problemInfo = await storageFolder.CreateFileAsync("problem.txt", Windows.Storage.CreationCollisionOption.OpenIfExists);
var problemStream = await problemInfo.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
ulong problemSize = problemStream.Size;
using (var inputStream = problemStream.GetInputStreamAt(0))
{
using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream))
{
uint numBytesLoaded = await dataReader.LoadAsync((uint)problemSize);
string problemContent = dataReader.ReadString(numBytesLoaded);
if (problemContent == "")
{
selectProblemButton.Content = "choose a problem";
}
else
{
selectProblemButton.Content = problemContent.ToString();
}
}
}
problemStream.Dispose();
//Select room button
Windows.Storage.StorageFile roomInfo = await storageFolder.CreateFileAsync("room.txt", Windows.Storage.CreationCollisionOption.OpenIfExists);
var roomStream = await roomInfo.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
ulong roomSize = roomStream.Size;
using (var inputStream = roomStream.GetInputStreamAt(0))
{
using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream))
{
uint numBytesLoaded = await dataReader.LoadAsync((uint)roomSize);
string roomContent = dataReader.ReadString(numBytesLoaded);
if (roomContent == "")
{
selectRoomButton.Content = "choose a room";
}
else
{
selectRoomButton.Content = roomContent.ToString();
}
}
}
roomStream.Dispose();
}
private async void LoadFavorites()
{
FavouritesList = new List <FavouritesJSON>();
string filepath = @"Assets\Favorites.json";
StorageFolder folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
StorageFile file = await folder.GetFileAsync(filepath); // error here
var JSONData = "e";
try
{
if ((bool)localSettings.Values["FirstFavRun"] == true)
{
localSettings.Values["FirstFavRun"] = false;
StorageFile sfile = await localFolder.CreateFileAsync("Favorites.json", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(sfile, JSONData);
JSONData = await Windows.Storage.FileIO.ReadTextAsync(file);
}
else
{
localSettings.Values["FirstFavRun"] = false;
StorageFile ssfile = await localFolder.GetFileAsync("Favorites.json");
JSONData = await FileIO.ReadTextAsync(ssfile);
}
}
catch
{
localSettings.Values["FirstFavRun"] = false;
StorageFile sssfile = await localFolder.CreateFileAsync("Favorites.json", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(sssfile, JSONData);
JSONData = await Windows.Storage.FileIO.ReadTextAsync(file);
}
localSettings.Values["FirstFavRun"] = false;
StorageFile sampleFile = await localFolder.CreateFileAsync("Favorites.json", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(sampleFile, JSONData);
FavouritesClass FavouritesListJSON = JsonConvert.DeserializeObject <FavouritesClass>(JSONData);
foreach (var item in FavouritesListJSON.Websites)
{
FavouritesList.Add(new FavouritesJSON()
{
HeaderJSON = item.HeaderJSON,
UrlJSON = item.UrlJSON,
FavIconJSON = item.FavIconJSON,
});
}
Favorites.ItemsSource = FavouritesList;
}
private async void DemoDataPersistenceCodeThroughFiles()
{
StorageFile localFileToWrite = await localFolder.CreateFileAsync("FileTest.txt", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(localFileToWrite, "This is a sample file!");
StorageFile localFileToRead = await localFolder.GetFileAsync("FileTest.txt");
string textRead = await FileIO.ReadTextAsync(localFileToRead);
StorageFile localFileToDelete = await localFolder.GetFileAsync("FileTest.txt");
await localFileToDelete.DeleteAsync();
}
public async Task saveAppendTextFile(StorageFolder folder, string data, string key = null)
{
StorageFile myFile;
if (key == null)
{
myFile = await folder.CreateFileAsync("myData.txt", CreationCollisionOption.OpenIfExists);
}
else
{
myFile = await folder.CreateFileAsync(key + ".txt", CreationCollisionOption.OpenIfExists);
}
await FileIO.AppendTextAsync(myFile, data);
await FileIO.AppendTextAsync(myFile, Environment.NewLine);
}
public async Task <bool> PersistObjectAsync <T>(string key, T value)
{
if (string.IsNullOrEmpty(key) || value == null)
{
return(false);
}
string xml = Serialize(value);
var file = await settingsFolder.CreateFileAsync(key, CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(file, xml);
return(true);
}
private async void SendMailClicked(object sender, RoutedEventArgs e)
{
if (isEmailInfoFilled())
{
AnalysisSampleDataItem selectedItem = RecordGrid.SelectedItem as AnalysisSampleDataItem;
if (selectedItem != null)
{
Windows.Storage.StorageFolder temporaryFolder = ApplicationData.Current.TemporaryFolder;
StorageFile sampleFile = await temporaryFolder.CreateFileAsync(selectedItem.Name.Trim() + ".csv", CreationCollisionOption.ReplaceExisting);
EmailInfoForm.IsOpen = false;
AnalysisPageCmdbar.IsOpen = false;
await FileIO.WriteTextAsync(sampleFile, ExtraModules.getFileDataForAnalysisItem(selectedItem));
AnalysisExportProgressRing.IsActive = true;
AnalysisExportProgressRing.Visibility = Windows.UI.Xaml.Visibility.Visible;
await ExtraModules.Send_Email(FromEmail.Text, FromPassword.Password, ToEmail.Text, Subject.Text, "Check from Health Organiser", sampleFile.Path);
await sampleFile.DeleteAsync(StorageDeleteOption.PermanentDelete);
AnalysisExportProgressRing.IsActive = false;
AnalysisExportProgressRing.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
this.clearEmailInfoFields();
}
else
{
EmailInfoForm.IsOpen = false;
}
}
AnalysisPageCmdbar.IsOpen = false;
}
private async void Submit_Click(object sender, RoutedEventArgs e)
{
String fileName = "Details.txt";
String name = Name.Text + Environment.NewLine;
String email = Email.Text + Environment.NewLine;
String address = Address.Text + Environment.NewLine;
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
await storageFolder.CreateFileAsync("Details.txt",
Windows.Storage.CreationCollisionOption.ReplaceExisting);
Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file = await localFolder.GetFileAsync(fileName);
await FileIO.WriteTextAsync(file, name);
// await FileIO.AppendTextAsync(file, name);
await FileIO.AppendTextAsync(file, email);
await FileIO.AppendTextAsync(file, address);
Frame.Navigate(typeof(TicketSent));
}
async public static Task UnZipFile(StorageFile file, StorageFolder extractFolder = null)
{
using (var zipStream = await file.OpenStreamForReadAsync())
{
using (MemoryStream zipMemoryStream = new MemoryStream((int)zipStream.Length))
{
await zipStream.CopyToAsync(zipMemoryStream);
using (var archive = new ZipArchive(zipMemoryStream, ZipArchiveMode.Read))
{
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.Name != "")
{
using (Stream fileData = entry.Open())
{
StorageFile outputFile = await extractFolder.CreateFileAsync(entry.Name, CreationCollisionOption.ReplaceExisting);
using (Stream outputFileStream = await outputFile.OpenStreamForWriteAsync())
{
await fileData.CopyToAsync(outputFileStream);
await outputFileStream.FlushAsync();
}
}
}
}
}
}
}
}
/// <summary>
/// Saves
/// </summary>
/// <param name="errorMessage"></param>
public async static void SaveError(string errorMessage)
{
string newCaseStart = $"\r\nDate: {DateTime.Now.ToShortDateString()}\r\n ";
const string caseEnd = "\r\n- - -";
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile errorLog;
//Check for existing file
if (File.Exists(storageFolder.Path + "/InfoScreen-ErrorLog.txt"))
{
//Select file
errorLog = await storageFolder.GetFileAsync("InfoScreen-ErrorLog.txt");
//Add to file
await FileIO.AppendTextAsync(errorLog, $"{newCaseStart} {errorMessage} {caseEnd}");
}
else
{
//Create or replace existing file.
errorLog = await storageFolder.CreateFileAsync("InfoScreen-ErrorLog.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(errorLog, $"" + newCaseStart + errorMessage + caseEnd);
}
}
//We use a protected override void to execute code as soon as the page is loaded into memory
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile signInInfo = await storageFolder.CreateFileAsync("signin.txt", Windows.Storage.CreationCollisionOption.OpenIfExists);
var stream = await signInInfo.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
ulong size = stream.Size;
using (var inputStream = stream.GetInputStreamAt(0))
{
using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream))
{
uint numBytesLoaded = await dataReader.LoadAsync((uint)size);
string signinAddress = dataReader.ReadString(numBytesLoaded);
//string currentUser = emailBox.Text;
if (signinAddress.ToString() == "")
{
emailBox.Text = "@wh-at.net";
}
else
{
emailBox.Text = signinAddress.ToString();
Frame.Navigate(typeof(helpdesk));
}
}
}
stream.Dispose();
}
//Ouput the new value of the Dropdown into Text
async void DropdownValueChanged(Dropdown change)
{
#if UNITY_WSA && !UNITY_EDITOR
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync(gameDataFileName,
Windows.Storage.CreationCollisionOption.OpenIfExists);
string filePath = file.Path;
#else
string filePath = Path.Combine(Application.streamingAssetsPath, gameDataFileName);
#endif
if (File.Exists(filePath))
{
// Read the json from the file into a string
string dataAsJson = File.ReadAllText(filePath);
// Pass the json to JsonUtility, and tell it to create a GameData object from it
dynamic jsonObj = Newtonsoft.Json.JsonConvert.DeserializeObject(dataAsJson);
jsonObj["loadedmap"] = m_Dropdown.options[change.value].text;
string output = Newtonsoft.Json.JsonConvert.SerializeObject(jsonObj, Newtonsoft.Json.Formatting.Indented);
//File.WriteAllText(filePath, output);
#if UNITY_WSA && !UNITY_EDITOR
await Windows.Storage.FileIO.WriteTextAsync(file, output);
#else
File.WriteAllText(filePath, output);
#endif
}
else
{
Debug.LogError("Cannot load task data!");
}
}
private const string filename = "UserPreference.txt"; //TODO: Move to constant file
/// <summary>
/// This checkes for strResponse - if not null, will try to write
/// </summary>
/// <param name="strResponse"></param>
public async void CacheUserPreference(string strResponse)
{
roamingFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
StorageFile file = await roamingFolder.CreateFileAsync(filename,CreationCollisionOption.OpenIfExists);
if (strResponse != null)
await FileIO.AppendTextAsync(file, strResponse);
}
public async static Task SaveFileToLocal(string fileName, string token)
{
Windows.Storage.StorageFolder newFolder = await Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList.GetFolderAsync(token);
Windows.Storage.StorageFile newFile = await newFolder.CreateFileAsync(fileName, Windows.Storage.CreationCollisionOption.ReplaceExisting);
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalCacheFolder;
Windows.Storage.StorageFile tragetFile = await storageFolder.GetFileAsync(fileName);
var buffer = await Windows.Storage.FileIO.ReadBufferAsync(tragetFile);
await Windows.Storage.FileIO.WriteBufferAsync(newFile, buffer);
#region ReadWriteStream
//string contentText = null;
//using (var stream = await tragetFile.OpenAsync(Windows.Storage.FileAccessMode.Read))
//{
// ulong size = stream.Size;
// var inputStream = stream.GetInputStreamAt(0);
// var dataReader = new Windows.Storage.Streams.DataReader(inputStream);
// uint numBytesLoaded = await dataReader.LoadAsync((uint)size);
// contentText = dataReader.ReadString(numBytesLoaded);
//}
//using (var stream = await newFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
//{
// var outputStream = stream.GetOutputStreamAt(0);
// var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream);
// dataWriter.WriteString(contentText);
// await dataWriter.StoreAsync();
// await outputStream.FlushAsync();
//}
#endregion
}
public async Task SaveMetaInfo(string key)
{
Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
var file = await localFolder.CreateFileAsync(key + ChmMetaFileExtension, CreationCollisionOption.OpenIfExists);
await SaveMetaInfo(file);
}
/// <summary>
/// Writes a string to a text file.
/// </summary>
/// <param name="text">The text to write.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="folder">The folder.</param>
/// <param name="options">
/// The enum value that determines how responds if the fileName is the same
/// as the name of an existing file in the current folder. Defaults to ReplaceExisting.
/// </param>
/// <returns></returns>
public static async Task SaveAsync(
this string text,
string fileName,
StorageFolder folder = null,
CreationCollisionOption options = CreationCollisionOption.ReplaceExisting)
{
folder = folder ?? ApplicationData.Current.LocalFolder;
var file = await folder.CreateFileAsync(
fileName,
options);
using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (var outStream = fs.GetOutputStreamAt(0))
{
using (var dataWriter = new DataWriter(outStream))
{
if (text != null)
dataWriter.WriteString(text);
await dataWriter.StoreAsync();
dataWriter.DetachStream();
}
await outStream.FlushAsync();
}
}
}
private async void CleanHistoryBtn_Click(object sender, RoutedEventArgs e)
{
Windows.Storage.StorageFolder localFolder = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync("OCR_UKW_Project", Windows.Storage.CreationCollisionOption.OpenIfExists);
var DataFile = await localFolder.CreateFileAsync("OCR_UKW_Project_UserData.txt", CreationCollisionOption.OpenIfExists);
try
{
StorageFolder OCRFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync("OCR_UKW_Project");
if (OCRFolder != null)
{
await OCRFolder.DeleteAsync(StorageDeleteOption.PermanentDelete);
ApplicationData.Current.LocalSettings.Values[LBoxHistory.Name] = 0;
}
}
catch (Exception ex)
{
Windows.UI.Popups.MessageDialog msg = new Windows.UI.Popups.MessageDialog(ex.ToString());
await msg.ShowAsync();
}
LBoxHistory.Items.Clear();
this.Frame.Navigate(typeof(MainPage));
}
public async Task autoSaveMap()
{
try
{
String now = DateTime.Now.ToString("yyyyMMddHHmmssfff");
Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
if (localFolder != null)
{
IReadOnlyList <StorageFile> dirFiles = await localFolder.GetFilesAsync();
if (dirFiles != null)
{
if (dirFiles.Count > maxAutoSaves)
{
String filename = dirFiles.First().Name;
StorageFile firstfile = await localFolder.GetFileAsync(filename);
await firstfile.DeleteAsync();
}
}
String name = "Autosave" + now + ".ppm";
Windows.Storage.StorageFile file = await localFolder.CreateFileAsync(name);
filemanager.WriteFile(path, file);
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Autosave failed: Message:" + e.Message);
}
}
public static async Task OutputSensorDataAsync()
{
// ファイルの作成 すでに存在する場合は置き換える
Windows.Storage.StorageFolder documentsLibrary = KnownFolders.DocumentsLibrary;
Windows.Storage.StorageFile file = await documentsLibrary.CreateFileAsync(sensorDataFileName, Windows.Storage.CreationCollisionOption.ReplaceExisting);
// ファイルへの書き込み
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
dataWriter.WriteString("valueX valueY valueZ time\n");
if (Sensor_Values_Record_Time_List != null)
{
for (int i = 0; i < Sensor_Values_Record_Time_List.Count; i++)
{
dataWriter.WriteString($"{Math.Round(Sensor_ValueX_List[i], 3)} {Math.Round(Sensor_ValueY_List[i], 3)} {Math.Round(Sensor_ValueZ_List[i], 3)} {Math.Round(Sensor_Values_Record_Time_List[i], 2)}\n");
}
}
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well.
}
private async void download(object sender, RoutedEventArgs e)
{
var item = listview.SelectedItem as CloudBlockBlob;
var blob = App.container.GetBlockBlobReference(item.Name);
StorageFile file;
try
{
if (listview.SelectedIndex != -1)
{
file = await temporaryFolder.CreateFileAsync(item.Name,
CreationCollisionOption.ReplaceExisting);
using (var fileStream = await file.OpenStreamForWriteAsync())
{
var outputstream = fileStream.AsOutputStream();
//Hither
InMemoryRandomAccessStream decstream = new InMemoryRandomAccessStream();
System.IO.Stream netstream = System.IO.WindowsRuntimeStreamExtensions.AsStreamForRead(decstream);
//Hence
Stream saveStr = new System.IO.MemoryStream();
IOutputStream winStr = System.IO.WindowsRuntimeStreamExtensions.AsOutputStream(saveStr);
// var bufferstream = outputstream.AsStreamForWrite(UInt16.MaxValue);
await blob.DownloadToStreamAsync(winStr);
saveStr.Position = 0;
saveStr.CopyTo(fileStream);
fileStream.Flush();
}
// Make sure it's an image file.
imgbox.Source = new BitmapImage(new Uri(file.Path));
IbState.Text = "Success\n" + file.Path;
}
}
catch (Exception ex)
{
IbState.Text += (ex.Message + "\n");
}
}
private async void RenderInkImageAsync()
{
IReadOnlyList <InkStroke> currentStrokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
if (currentStrokes.Count > 0)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.TemporaryFolder;
Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync($"{Guid.NewGuid()}.png", Windows.Storage.CreationCollisionOption.ReplaceExisting);
if (file != null)
{
Windows.Storage.CachedFileManager.DeferUpdates(file);
IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (IOutputStream outputStream = stream.GetOutputStreamAt(0))
{
await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(outputStream);
await outputStream.FlushAsync();
}
stream.Dispose();
}
BitmapImage bm = new BitmapImage(new Uri($"ms-appdata:///temp/{file.Name}"));
App.ViewModel.SelectedDocument.AnnotationImage = bm;
}
Frame.GoBack();
}
public async Task itializeClass()
{
QueueCycleMilliSeconds = 500;
this.folder = Windows.Storage.ApplicationData.Current.LocalFolder;
try
{
this.file = folder.CreateFileAsync("SparkQueueDB.txt", CreationCollisionOption.OpenIfExists).AsTask().Result;
}
catch (Exception ex)
{
this.Errors.Add("Queue Failed To Initialize");
this.Errors.Add(ex.Message.ToString());
}
inboundQueue = new Queue();
outboundQueue = new Queue();
//if (Program.strPowerOuttageMissedDownEvent.Length > 1)
//{
// this.Enqueue(Program.strPowerOuttageMissedDownEvent);
// Program.strPowerOuttageMissedDownEvent = "";
//}
InboundDataTimer = new Timer(new TimerCallback(ProcessInboundEvent), new Object(), 250, 250);
OutboundDataTimer = new Timer(new TimerCallback(ProcessOutboundEvent), new Object(), 250, 250);
this.file = null;
this.folder = null;
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
var folderpicker = new Windows.Storage.Pickers.FolderPicker();
folderpicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.ComputerFolder;
folderpicker.FileTypeFilter.Add("*");
Windows.Storage.StorageFolder folder = await folderpicker.PickSingleFolderAsync();
string pathstr = folder.Path;
Windows.Storage.StorageFile file = await folder.CreateFileAsync("sample.txt", CreationCollisionOption.GenerateUniqueName);
List <string> output = new List <string>();
foreach (StorageFile sfile in await folder.GetFilesAsync())
{
output.Add(sfile.Name + "\n");
}
stores.ItemsSource = output;
if (!string.IsNullOrEmpty(path.Text) && !string.IsNullOrWhiteSpace(path.Text))
{
//string Path = path.Text;
//DataAccess.AddData(Path);
//StoreDirectories.Stores = await DataAccess.GetStores();
//stores.ItemsSource = StoreDirectories.Stores;
}
}
private async void Button_Click_1(object sender, RoutedEventArgs e)
{
using (var captureStream = new InMemoryRandomAccessStream())
{
var pngProperties = ImageEncodingProperties.CreatePng();
//pngProperties.Width = (uint)pictureBox1.Width;
//pngProperties.Height = (uint)pictureBox1.Height;
pngProperties.Width = (uint)PreviewFrameImage.ActualWidth;
pngProperties.Height = (uint)PreviewFrameImage.ActualHeight;
AddLog("キャプチャ開始");
//await mediaCapture.CapturePhotoToStreamAsync(pngProperties, captureStream);
Windows.Storage.StorageFolder storageFolder = await StorageFolder.GetFolderFromPathAsync(Environment.GetFolderPath(Environment.SpecialFolder.Desktop));
Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync("sample.bmp", Windows.Storage.CreationCollisionOption.ReplaceExisting);
//await mediaCapture.CapturePhotoToStorageFileAsync(ImageEncodingProperties.CreatePng(), sampleFile);
captureStream.Seek(0);
AddLog("AsStream");
//ビットマップにして表示
System.IO.Stream stream = System.IO.WindowsRuntimeStreamExtensions.AsStream(captureStream);
var img = System.Drawing.Bitmap.FromStream(stream);
//this.pictureBox1.Image = img;
//img.Save(Environment.SpecialFolder.Desktop + @"\aaa.bmp");
AddLog("表示");
// 画面に表示
var a = System.Windows.Media.Imaging.BitmapFrame.Create(stream, System.Windows.Media.Imaging.BitmapCreateOptions.None, System.Windows.Media.Imaging.BitmapCacheOption.OnLoad);
PreviewFrameImage.Source = a;
}
}
/// <summary>
/// 向AppData中的rtf文本中写入string
/// </summary>
/// <param name="fileName">AppData目录下的文件名，需要带拓展名</param>
/// <param name="content">要写入的内容</param>
/// <param name="tag">要选择的模式</param>
/// <returns>文本信息</returns>
public async Task SetStringToFile(string fileName, string content, int tag)
{
//ExportFile Service
Windows.Storage.Pickers.FileSavePicker savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
savePicker.FileTypeChoices.Add("Rich Text", new List <string>()
{
".rtf"
});
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = "New Document";
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file;
if (tag == 1)
{
file = await storageFolder.CreateFileAsync(fileName, Windows.Storage.CreationCollisionOption.ReplaceExisting);
}
else
{
file = await storageFolder.GetFileAsync(fileName);
}
if (file != null)
{
System.IO.File.WriteAllText(file.Path, content);
await new Windows.UI.Popups.MessageDialog("添加成功").ShowAsync();
}
}
private async System.Threading.Tasks.Task StoreURLDataAsync(String url, String price)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync("urls.txt", Windows.Storage.CreationCollisionOption.OpenIfExists);
await Windows.Storage.FileIO.AppendTextAsync(file, url + " -br- " + price);
}
private async void lvwBlobs_ItemClick(object sender, ItemClickEventArgs e)
{
var item = e.ClickedItem as CloudBlockBlob;
var blob = App.container.GetBlockBlobReference(item.Name);
StorageFile file;
try
{
Windows.Storage.StorageFolder temporaryFolder = ApplicationData.Current.TemporaryFolder;
file = await temporaryFolder.CreateFileAsync(item.Name,
CreationCollisionOption.ReplaceExisting);
// ProcessBegin();
var downloadTask = blob.DownloadToFileAsync(file);
await downloadTask;
//downloadTask.Completed = (IAsyncAction asyncInfo, AsyncStatus asyncStatus) =>
//{
// ProcessEnd();
//};
// Make sure it's an image file.
imgBlobItem.Source = new BitmapImage(new Uri(file.Path));
}
catch (Exception ex)
{
statusAzure.Text = (ex.Message + "\n");
}
}
public async void PrintPDF(Memo memo)
{
Reports = new Reports(memo);
//var stream = new InMemoryRandomAccessStream();
//FileSavePicker fileSavePicker = new FileSavePicker();
WriterFormat format = WriterFormat.PDF;
//fileSavePicker.SuggestedFileName = "ExportReport";
//var savedItem = await fileSavePicker.PickSaveFileAsync();
//if (savedItem != null)
//
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile savedItem =
await storageFolder.CreateFileAsync("sample.pdf",
Windows.Storage.CreationCollisionOption.ReplaceExisting);
//var savedItem = await FileSavePicker.PickSaveFileAsync();
MemoryStream exportFileStream = new MemoryStream();
Assembly assembly = typeof(HomePage).GetTypeInfo().Assembly;
// Ensure the report loaction and application name.
Stream reportStream = assembly.GetManifestResourceStream("UwpApp.Report.Inv.rdlc");
BoldReports.UI.Xaml.ReportDataSourceCollection datas = new BoldReports.UI.Xaml.ReportDataSourceCollection();
datas.Add(new BoldReports.UI.Xaml.ReportDataSource {
Name = "PatientInfo", Value = Reports.LoadReport()
});
datas.Add(new BoldReports.UI.Xaml.ReportDataSource {
Name = "MemoDetails", Value = Reports.loadmemodetail()
});
ReportWriter writer = new ReportWriter(reportStream, datas);
writer.ExportMode = ExportMode.Local;
await writer.SaveASync(exportFileStream, format);
try
{
using (IRandomAccessStream stream = await savedItem.OpenAsync(FileAccessMode.ReadWrite))
{
// Write compressed data from memory to file
using (Stream outstream = stream.AsStreamForWrite())
{
byte[] buffer = exportFileStream.ToArray();
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
exportFileStream.Dispose();
}
catch { }
}
private async void save_Click(object sender, RoutedEventArgs e)
{
bool seen = false;
for (int i = 0; i < dropdown.Items.Count; i++)
{
if (groupname == (string)(dropdown.Items[i] as ComboBoxItem).Content)
{
seen = true;
}
}
if (!seen)
{
ComboBoxItem TI = new ComboBoxItem();
TI.Content = groupname;
dropdown.Items.Add(TI);
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync("videos" + groupname + ".txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
await Windows.Storage.FileIO.WriteTextAsync(sampleFile, vids.Text);
}
else
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync("videos" + groupname + ".txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
await Windows.Storage.FileIO.WriteTextAsync(sampleFile, vids.Text);
return;
}
}
/// <summary>
/// 创建并获取当前文件（临时文件夹）
/// </summary>
/// <param name="FileName"></param>
/// <returns></returns>
public async Task <Windows.Storage.StorageFile> CreatFile(string FileName)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.TemporaryFolder;
Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync(FileName, Windows.Storage.CreationCollisionOption.ReplaceExisting);
return(await storageFolder.GetFileAsync(FileName));
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
/*参考文档: https://docs.microsoft.com/zh-cn/windows/uwp/files/quickstart-using-file-and-folder-pickers */
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add("*");
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile imagefile = await storageFolder.CreateFileAsync("avatar", CreationCollisionOption.ReplaceExisting);
imagefile = await picker.PickSingleFileAsync();
if (imagefile != null) //若选中了图片，则将该图片填充头像，并保存图像地址
{
imgpath = imagefile.Path;
localSettings.Containers[username.Text].Values["avatar"] = imgpath;
ImageBrush brush = new ImageBrush();
BitmapImage bitmap = new BitmapImage();
using (var stream = await imagefile.OpenAsync(FileAccessMode.ReadWrite)) //需要使用文件流才能访问storagefile图片路径
{
bitmap.SetSource(stream);
}
brush.ImageSource = bitmap;
Avator.Fill = brush;
}
}
//save sessin to file:
public static async void SaveSession()
{
if (InstaApi == null)
{
return;
}
if (!InstaApi.IsUserAuthenticated)
{
return;
}
_lastUser = _user;
// Create file; replace if exists.
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
// mage mikhai chand ta id azash login koni hamzaman? are
// bish az 5 ta bashe block mishi, dah ta 1a dare
// dah ta yeka dare yani che:| 10 ta ja dare, bedone moshkel
Windows.Storage.StorageFile File = await storageFolder.CreateFileAsync(_user + ".txt", Windows.Storage.CreationCollisionOption.ReplaceExisting);
await Windows.Storage.FileIO.WriteTextAsync(File, InstaApi.GetStateDataAsString());
localSettings.Values["ihaveaaccount"] = "yes";
localSettings.Values["LastUser"] = _lastUser;
}
/// <summary>
/// 新账号数据保存
/// 参考文档 https://jingyan.baidu.com/article/67508eb47a05499cca1ce430.html
/// </summary>
/// <param name="id"></param>
public async static Task <int> NewAccount(string uid)
{
if (uid != null)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; //调用API，获取本地存储文件夹对象
Windows.Storage.StorageFile serializeFile = await storageFolder.CreateFileAsync(uid + ".bat", CreationCollisionOption.ReplaceExisting); //创建本地存储文件对象，模式为覆盖
try
{
Stream fs = await serializeFile.OpenStreamForWriteAsync(); //创建文件写入的数据流对象(异步方法)
using (XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateTextWriter(fs, Encoding.UTF8))
{
DataContractSerializer dcs = new DataContractSerializer(typeof(Dictionary <string, Contacts>));
dcs.WriteObject(xdw, new Dictionary <string, Contacts>());
}
return(1); //无异常，返回值为1
}
catch (Exception e)
{
var dialog = new MessageDialog("");
dialog.Content = "Create New Accout Exception";
await dialog.ShowAsync();
return(0); // 出现异常，返回值为0
}
}
else
{
return(0);
}
}
public static async Task WriteNewLogAsync(StorageFile file, StorageFolder folder, string fileName, string logString)
{
if (!(await FileUtil.DoesFileExistAsync(file, folder, fileName)))
{
file = await folder.CreateFileAsync(fileName);
}
await FileIO.AppendTextAsync(file, logString + Environment.NewLine);
}
public static async Task<StorageFile> SetFile(StorageFolder folder, string fileName)
{
StorageFile file = null;
if (!(await DoesFileExistAsync(file, folder, fileName)))
{
file = await folder.CreateFileAsync(fileName);
}
return file;
}
async public static Task ZipFolder(StorageFolder sourceFolder, StorageFolder destnFolder, string zipFileName)
{
StorageFile zipFile = await destnFolder.CreateFileAsync(zipFileName, CreationCollisionOption.ReplaceExisting);
Stream zipToCreate = await zipFile.OpenStreamForWriteAsync();
ZipArchive archive = new ZipArchive(zipToCreate, ZipArchiveMode.Update);
await ZipFolderContents(sourceFolder, archive, sourceFolder.Path);
archive.Dispose();
}
public async void download(String url, Folder folder)
{
var uri = new Uri(url);
var downloader = new BackgroundDownloader();
StorageFile file = await folder.CreateFileAsync("100MB.zip",
CreationCollisionOption.ReplaceExisting);
DownloadOperation download = downloader.CreateDownload(uri, file);
download.StartAsync();
}
public async static Task SaveAsync(this InkCanvas inkCanvas, string fileName, StorageFolder folder = null)
{
folder = folder ?? ApplicationData.Current.TemporaryFolder;
var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
if (inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Any())
{
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(stream);
}
}
}
/// <summary>
/// 要下载调用这个方法
/// </summary>
/// <param name="url">下载的文件网址的来源</param>
/// <returns></returns>
public static async Task Start(string filename,string url,DownloadType type,StorageFolder folder=null)
{
try
{
Uri uri = new Uri(Uri.EscapeUriString(url), UriKind.RelativeOrAbsolute);
BackgroundDownloader downloader = new BackgroundDownloader();
if (folder==null)
{
folder = await KnownFolders.MusicLibrary.CreateFolderAsync("kgdownload", CreationCollisionOption.OpenIfExists);
switch (type)
{
case DownloadType.song:
folder = await folder.CreateFolderAsync("song", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("song");
break;
case DownloadType.mv:
folder = await folder.CreateFolderAsync("mv", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("mv");
break;
case DownloadType.other:
folder = await folder.CreateFolderAsync("other", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
break;
default:
break;
}
}else
{
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
}
//string name = uri.ToString().Substring(uri.ToString().LastIndexOf("/"), uri.ToString().Length);
string name = filename;
StorageFile file = await folder.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName);
downloader.FailureToastNotification = DownloadedToast.Done(filename, DownloadedToast.DownResult.Fa);
downloader.SuccessToastNotification = DownloadedToast.Done(filename, DownloadedToast.DownResult.Su);
var download = downloader.CreateDownload(new Uri(url), file);
TransferModel transfer = new TransferModel();
transfer.DownloadOperation = download;
transfer.Source = download.RequestedUri.ToString();
transfer.Destination = download.ResultFile.Path;
transfer.BytesReceived = download.Progress.BytesReceived;
transfer.TotalBytesToReceive = download.Progress.TotalBytesToReceive;
transfer.Progress = 0;
transfers.Add(transfer);
Progress<DownloadOperation> progressCallback = new Progress<DownloadOperation>(DownloadProgress);
download.StartAsync().AsTask(cancelToken.Token, progressCallback);
}
catch
{
await new MessageDialog("链接已失效！").ShowAsync();
}
}
internal async static Task MergeFolders(StorageFolder source, StorageFolder target)
{
foreach (StorageFile sourceFile in await source.GetFilesAsync())
{
await sourceFile.CopyAndReplaceAsync(await target.CreateFileAsync(sourceFile.Name, CreationCollisionOption.OpenIfExists));
}
foreach (StorageFolder sourceDirectory in await source.GetFoldersAsync())
{
StorageFolder nextTargetSubDir = await target.CreateFolderAsync(sourceDirectory.Name, CreationCollisionOption.OpenIfExists);
await MergeFolders(sourceDirectory, nextTargetSubDir);
}
}
private static async Task<IEnumerable<City>> CreateDefaultFileOfCities(StorageFolder folder)
{
var file = await folder.CreateFileAsync(SETTING_KEY);
var cities = new City[]
{
new City()
{
Name="Namur",
Country="Belgique"
}
};
await FileIO.WriteTextAsync(file, SerializeToJson(cities));
return cities;
}
private static async Task<string> RenderPage(Windows.Data.Pdf.PdfPage page, StorageFolder output)
{
var pagePath = string.Format("{0}.png", page.Index);
var pageFile = await output.CreateFileAsync(pagePath, CreationCollisionOption.ReplaceExisting);
using (var imageStream = await pageFile.OpenAsync(FileAccessMode.ReadWrite))
{
PdfPageRenderOptions pdfPageRenderOptions = new PdfPageRenderOptions();
pdfPageRenderOptions.IsIgnoringHighContrast = false;
await page.RenderToStreamAsync(imageStream, pdfPageRenderOptions);
await imageStream.FlushAsync();
}
return output.Path.ToFolderPath() + pagePath;
}
private async static Task<StorageFile> SaveAsync(
Uri fileUri,
StorageFolder folder,
string fileName)
{
var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
var downloader = new BackgroundDownloader();
var download = downloader.CreateDownload(
fileUri,
file);
var res = await download.StartAsync();
return file;
}
public async static Task SaveAsync(
Uri fileUri,
StorageFolder folder,
string fileName)
{
// Hitting System.UnauthorizedAccessException when the file already exists.
// If they already have it, keep what is there.
var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
var downloader = new BackgroundDownloader();
var download = downloader.CreateDownload(
fileUri,
file);
await download.StartAsync();
}
public async void Setup()
{
Folder = ApplicationData.Current.LocalFolder;
//połącz do pliku jesli istnieje
try
{
File = await Folder.GetFileAsync("json.txt");
}
//utwórz gdy go nie ma
catch
{
File = await Folder.CreateFileAsync("json.txt");
}
}
public static async Task SaveImageAsyncFromUri(string filename, StorageFolder folder, Uri url, CreationCollisionOption option)
{
if(folder != null)
{
StorageFile file = await folder.CreateFileAsync(filename, option);
HttpClient client = new HttpClient();
byte[] fileContent = await client.GetByteArrayAsync(url);
Stream fileStream = await file.OpenStreamForWriteAsync();
fileStream.Write(fileContent, 0, fileContent.Length);
fileStream.Flush();
fileStream.Dispose();
}
}
private static async Task InflateEntryAsync(ZipArchiveEntry entry, StorageFolder destFolder, bool createSub = false)
{
string filePath = entry.FullName;
if (!string.IsNullOrEmpty(filePath) && filePath.Contains("/") && !createSub)
{
// Create sub folder
string subFolderName = Path.GetDirectoryName(filePath);
StorageFolder subFolder;
// Create or return the sub folder.
subFolder = await destFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.OpenIfExists);
string newFilePath = Path.GetFileName(filePath);
if (!string.IsNullOrEmpty(newFilePath))
{
// Unzip file iteratively.
await InflateEntryAsync(entry, subFolder, true);
}
}
else
{
// Read uncompressed contents
using (Stream entryStream = entry.Open())
{
byte[] buffer = new byte[entry.Length];
entryStream.Read(buffer, 0, buffer.Length);
// Create a file to store the contents
StorageFile uncompressedFile = await destFolder.CreateFileAsync(entry.Name, CreationCollisionOption.ReplaceExisting);
// Store the contents
using (IRandomAccessStream uncompressedFileStream =
await uncompressedFile.OpenAsync(FileAccessMode.ReadWrite))
{
using (Stream outstream = uncompressedFileStream.AsStreamForWrite())
{
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
}
}
}
public async void DownDanMu(string cid, StorageFolder folder)
{
try
{
wc = new WebClientClass();
string results = await wc.GetResults(new Uri("http://comment.bilibili.com/" + cid + ".xml"));
//将弹幕存在在应用文件夹
//StorageFolder folder = ApplicationData.Current.LocalFolder;
//StorageFolder DowFolder = await KnownFolders.VideosLibrary.CreateFolderAsync("Bili-Download", CreationCollisionOption.OpenIfExists);
StorageFile fileWrite = await folder.CreateFileAsync(cid + ".xml", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(fileWrite, results);
}
catch (Exception)
{
//return null;
}
}
/// <summary>
/// Saves the WriteableBitmap to a file in the given folder with the given file name.
/// </summary>
/// <param name="writeableBitmap">The writeable bitmap.</param>
/// <param name="storageFolder">The storage folder.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="options">
/// The enum value that determines how responds if the fileName is the same
/// as the name of an existing file in the current folder. Defaults to ReplaceExisting.
/// </param>
/// <returns></returns>
public static async Task<StorageFile> SaveToFile(
this WriteableBitmap writeableBitmap,
StorageFolder storageFolder,
string fileName,
CreationCollisionOption options = CreationCollisionOption.ReplaceExisting)
{
StorageFile outputFile =
await storageFolder.CreateFileAsync(
fileName,
options);
Guid encoderId;
var ext = Path.GetExtension(fileName);
if (new[] { ".bmp", ".dib" }.Contains(ext))
{
encoderId = BitmapEncoder.BmpEncoderId;
}
else if (new[] { ".tiff", ".tif" }.Contains(ext))
{
encoderId = BitmapEncoder.TiffEncoderId;
}
else if (new[] { ".gif" }.Contains(ext))
{
encoderId = BitmapEncoder.GifEncoderId;
}
else if (new[] { ".jpg", ".jpeg", ".jpe", ".jfif", ".jif" }.Contains(ext))
{
encoderId = BitmapEncoder.JpegEncoderId;
}
else if (new[] { ".hdp", ".jxr", ".wdp" }.Contains(ext))
{
encoderId = BitmapEncoder.JpegXREncoderId;
}
else //if (new [] {".png"}.Contains(ext))
{
encoderId = BitmapEncoder.PngEncoderId;
}
await writeableBitmap.SaveToFile(outputFile, encoderId);
return outputFile;
}
public static async Task<StorageFile> CreateFileAsync(string path, StorageFolder folder,
CreationCollisionOption option = CreationCollisionOption.OpenIfExists)
{
if (path.StartsWith("/") || path.StartsWith("\\"))
path = path.Substring(1);
var parts = path.Split('/');
var fileName = parts.Last();
if (parts.Length > 1)
{
folder =
await
EnsureFolderExistsAsync(path.Substring(0, path.Length - fileName.Length), folder)
.ConfigureAwait(false);
}
return await folder.CreateFileAsync(fileName, option).AsTask().ConfigureAwait(false);
}
// This is a private method, and does not require synchronization. We assume caller is
// already holding the lock.
private static async Task<StorageFile> GetOrCreateFileAsync(StorageFolder storageFolder, string fileName)
{
StorageFile storageFile = null;
try
{
Debug.WriteLine("File location: {0}", storageFolder.Path);
storageFile = await storageFolder.GetFileAsync(fileName);
}
catch (FileNotFoundException)
{
Debug.WriteLine("File not found: {0}", fileName);
}
if (storageFile == null)
{
storageFile = await storageFolder.CreateFileAsync(fileName);
}
return storageFile;
}
private async Task RStorage(StorageFolder folder)
{
//name
//作者
//简介
//目录
//脚注
string emptyStr = "<!--{0}-->\r\n";
StringBuilder str = new StringBuilder();
//<!--目录-->
str.Append(string.Format(emptyStr, "name"));
str.Append(folder.Name + "\r\n");
str.Append(string.Format(emptyStr, "name"));
str.Append(string.Format(emptyStr, "作者"));
str.Append(AuthoStr + "\r\n");
str.Append(string.Format(emptyStr, "作者"));
str.Append(string.Format(emptyStr, "简介"));
str.Append(Introduction);
str.Append(string.Format(emptyStr, "简介"));
str.Append(string.Format(emptyStr, "目录"));
foreach (var temp in FolderStorage)
{
str.Append(string.Format("[{0}]({1})\r\n", temp.Name, temp.FolderStorage.Path.Replace(
folder.Path, ".")));
}
str.Append(string.Format(emptyStr, "目录"));
str.Append(string.Format(emptyStr, "脚注"));
str.Append(Artis);
str.Append(string.Format(emptyStr, "脚注"));
StorageFile file = await folder.CreateFileAsync("README.md", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(file, str.ToString());
}
private static async void CreateFile(StorageFolder folder, string fileName)
{
await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
}
public static async Task CreateFile(string filename, StorageFolder folder)
{
// Create sample file; replace if exists.
StorageFile sampleFile = await folder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
}
/// <summary>
/// Private Methods & Testing Methods.
/// </summary>
private async Task<StorageFile> CreateFileToLocalStorageAsync(string path, StorageFolder folder)
{
string name;
string[] list = ParseHelper.ParsePathAndName(path, ParseHelper.Mode.FULL_PATH, out name); // changed DIRECTORY to FULL_PATH
foreach (string s in list)
{
folder = await folder.CreateFolderAsync(s, CreationCollisionOption.OpenIfExists);
}
return await folder.CreateFileAsync(name, CreationCollisionOption.OpenIfExists);
}
public async Task<StorageFile> CreateFile(StorageFolder folder, string filename, CreationCollisionOption option)
{
return await folder.CreateFileAsync(filename, option);
}
public static async Task<bool> AddDownload(string filename, string url, DownloadType type, StorageFolder folder = null)
{
try
{
var down = new BackgroundDownloader();
down.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
if (folder == null)
{
folder = await KnownFolders.MusicLibrary.GetFolderAsync("kgdownload");
switch (type)
{
case DownloadType.song:
folder = await folder.GetFolderAsync("song");
down.TransferGroup = BackgroundTransferGroup.CreateGroup("song");
break;
case DownloadType.mv:
folder = await folder.GetFolderAsync("mv");
down.TransferGroup = BackgroundTransferGroup.CreateGroup("mv");
break;
case DownloadType.other:
folder = await folder.GetFolderAsync("other");
down.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
break;
default:
break;
}
}
var files= (await folder.GetFilesAsync()).ToList();
foreach (var item in files)
{
await item.DeleteAsync();
}
var file = await folder.CreateFileAsync(filename);
down.FailureToastNotification = DownloadToast(filename, DownloadResult.Failure);
down.SuccessToastNotification = DownloadToast(filename, DownloadResult.Success);
var opera= down.CreateDownload(new Uri(url), file);
opera.CostPolicy = BackgroundTransferCostPolicy.Always;
opera.StartAsync();
return true;
}
catch (Exception)
{
return false;
}
}
private async static Task<StorageFile> GetFile(StorageFolder folder)
{
return await folder.CreateFileAsync("PowerOuttageHandler.txt", CreationCollisionOption.ReplaceExisting);
}
