private async Task OpenFilePDFViewer(IStorageFile file, FileAccessMode mode) { if (file == null) { return; } Windows.Storage.Streams.IRandomAccessStream stream; try { stream = await file.OpenAsync(mode); } catch (Exception e) { // NOTE: If file already opened it will cause an exception var msg = new MessageDialog(e.Message); _ = msg.ShowAsync(); return; } PDFDoc doc = new PDFDoc(stream); doc.InitSecurityHandler(); // Set loaded doc to PDFView Controler PDFViewCtrl.SetDoc(doc); ThumbnailViewer = new ThumbnailViewer(PDFViewCtrl, file.Path); }
public async static Task <T> DeserializeFromFileAsync(IStorageFile file) { using (var stream = (await file.OpenAsync(FileAccessMode.Read)).GetInputStreamAt(0).AsStreamForRead()) { XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); return((T)xmlSerializer.Deserialize(stream)); } }
public static async Task<string> Hash(IStorageFile file) { string res = string.Empty; using(var streamReader = await file.OpenAsync(FileAccessMode.Read)) { var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5); var algHash = alg.CreateHash(); using(BinaryReader reader = new BinaryReader(streamReader.AsStream(), Encoding.UTF8)) { byte[] chunk; chunk = reader.ReadBytes(CHUNK_SIZE); while(chunk.Length > 0) { algHash.Append(CryptographicBuffer.CreateFromByteArray(chunk)); chunk = reader.ReadBytes(CHUNK_SIZE); } } res = CryptographicBuffer.EncodeToHexString(algHash.GetValueAndReset()); return res; } }
public async static void SerializeToFileAsync(T objectToSerialize, IStorageFile file) { using (var stream = (await file.OpenAsync(FileAccessMode.ReadWrite)).GetOutputStreamAt(0).AsStreamForWrite()) { XmlSerializer serializer = new XmlSerializer(typeof(T)); serializer.Serialize(stream, objectToSerialize); } }
public async void ReadHistoryData() { try { _historyFile = await _currentFolder.GetFileAsync(HistoryDataFilename); } catch (FileNotFoundException e) { Log.E(e.Message); Log.D(e.StackTrace); Log.D(e.Source); HistoryData = new HistoryData(); return; } using (var stream = await _historyFile.OpenAsync(FileAccessMode.ReadWrite)) { lock (_thisLock) { using (var reader = stream.AsStreamForRead()) { var obj = _serializer.ReadObject(reader); if (obj is HistoryData) { HistoryData = obj as HistoryData; } else { throw new SerializationException(nameof(obj) + " is not " + nameof(HistoryData)); } } } } }
public void WriteAllText(string filename, string text, Action completed) { StorageFolder localFolder = ApplicationData.Current.LocalFolder; IAsyncOperation <StorageFile> createOp = localFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); createOp.Completed = (asyncInfo1, asyncStatus1) => { IStorageFile storageFile = asyncInfo1.GetResults(); IAsyncOperation <IRandomAccessStream> openOp = storageFile.OpenAsync(FileAccessMode.ReadWrite); openOp.Completed = (asyncInfo2, asyncStatus2) => { IRandomAccessStream stream = asyncInfo2.GetResults(); DataWriter dataWriter = new DataWriter(stream); dataWriter.WriteString(text); DataWriterStoreOperation storeOp = dataWriter.StoreAsync(); storeOp.Completed = (asyncInfo3, asyncStatus3) => { dataWriter.Dispose(); completed(); }; }; }; }
/// <summary> /// 将图像写入到文件 /// </summary> /// <param name="writeableBitmap"></param> /// <param name="storageFile"></param> /// <returns></returns> public async Task SaveToStorageFile(WriteableBitmap writeableBitmap, IStorageFile storageFile, double dpi = 100.0) { var bitmap = new RenderTargetBitmap(); await bitmap.RenderAsync(qrcodeImage); var writeableBmp = await bitmap.GetPixelsAsync(); using (var writestream = await storageFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, writestream); using (var pixelStream = writeableBitmap.PixelBuffer.AsStream()) { var pixels = new byte[pixelStream.Length]; await pixelStream.ReadAsync(pixels, 0, pixels.Length); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)writeableBitmap.PixelWidth, (uint)writeableBitmap.PixelHeight, dpi, dpi, pixels); await encoder.FlushAsync(); UIHelper.ShowDialog("保存在相册:保存的图片 中", AlertIcon.Ok); } } }
public static async Task <bool> TryTranscodePhotoAsync(IStorageFile input, IStorageFile output, IProgress <double?> progress, CancellationToken token = default) { progress.Report(null); try { using (var inputStream = await input.OpenAsync(FileAccessMode.Read)) using (var outputStream = await output.OpenAsync(FileAccessMode.ReadWrite)) { var decoder = await BitmapDecoder.CreateAsync(inputStream); double width = (int)decoder.PixelWidth; double height = (int)decoder.PixelHeight; Drawing.ScaleProportions(ref width, ref height, 2048, 2048); var encoder = await BitmapEncoder.CreateForTranscodingAsync(outputStream, decoder); encoder.BitmapTransform.ScaledWidth = (uint)width; encoder.BitmapTransform.ScaledHeight = (uint)height; await encoder.FlushAsync(); return(true); } } catch { return(false); } }
private async Task <ImageResult> ResizeAsync(IStorageFile file, Size oldSize, Size newSize) { var newFile = await CreateNewFile(); try { using (IRandomAccessStream source = await file.OpenAsync(FileAccessMode.Read)) { var decoder = await BitmapDecoder.CreateAsync(source); var transform = new BitmapTransform { ScaledHeight = (uint)newSize.Height, ScaledWidth = (uint)newSize.Width }; var pixelData = await decoder.GetPixelDataAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); using (IRandomAccessStream destinationStream = await newFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, destinationStream); encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, (uint)newSize.Width, (uint)newSize.Height, 96, 96, pixelData.DetachPixelData()); await encoder.FlushAsync(); } } } catch (Exception ex) { if (_ensureSuccessfullScale) { throw new Exception("image can not be resized123"); } } return(new ImageResult(oldSize, newFile)); }
//Stream的读取操作 //使用Stream读取文件的内容,需要先调用DataReader类的LoadAsync方法,把数据加载进来,再调用相关的Read方法来读取文件的内容; //Buffer的操作不用调用LoadAsync方法,那是因为其已经一次性把数据都读取出来了 public async void StreamReader(IStorageFile file) { using (IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read)) { using (DataReader dataReader = new DataReader(readStream)) { //读取文件的相关信息,读取规则要与文件的规则一致 //await dataReader.LoadAsync(sizeof(Int32)); //Int32 stringSize = dataReader.ReadInt32(); //await dataReader.LoadAsync(4096); //string fileContent = dataReader.ReadString((uint)stringSize); //add test code uint size = await dataReader.LoadAsync(sizeof(uint)); if (size < sizeof(uint)) { return; } else { uint stringLength = dataReader.ReadUInt32(); uint actualStringLength = await dataReader.LoadAsync(stringLength); if (actualStringLength != stringLength) { // The underlying socket was closed before we were able to read the whole data return; } } } } }
public static async Task <Tuple <bool, byte[]> > FillBuffer(IStorageFile file, UploadablePart part) { try { if (part.ParentItem.FileNotFound) { return(new Tuple <bool, byte[]>(false, null)); } using (var stream = await file.OpenAsync(FileAccessMode.Read)) { using (var inStream = stream.GetInputStreamAt((ulong)part.Position)) { var bytes = new byte[part.Count]; using (var reader = new DataReader(inStream)) { await reader.LoadAsync((uint)bytes.Length); reader.ReadBytes(bytes); } // encrypting part if (part.ParentItem.Key != null && part.ParentItem.IV != null) { var key = part.ParentItem.Key; var iv = part.FilePart.Value == 0 ? part.ParentItem.IV : part.IV; if (iv == null) { return(new Tuple <bool, byte[]>(true, null)); } byte[] nextIV; var encryptedBytes = Utils.AesIge(bytes, key.Data, iv.Data, true, out nextIV); bytes = encryptedBytes; var nextPartId = part.FilePart.Value + 1; if (part.ParentItem.Parts.Count > nextPartId) { part.ParentItem.Parts[nextPartId].IV = TLString.FromBigEndianData(nextIV); } } return(new Tuple <bool, byte[]>(true, bytes)); } } } catch (FileNotFoundException ex) { Execute.ShowDebugMessage("FillBuffer FileNotFoundException\n" + ex); return(new Tuple <bool, byte[]>(false, null)); } catch (Exception ex) { Execute.ShowDebugMessage("FillBuffer Exception\n" + ex); return(new Tuple <bool, byte[]>(true, null)); } }
public async Task <RenderTargetBitmap> RenderToFileAsync(UIElement uiElement, IStorageFile file, Guid bitmapEncoder) { using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { return(await RenderToStreamAsync(uiElement, stream, bitmapEncoder)); } }
private async Task HandleSuccessfullDownload(SignalAttachment attachment, IStorageFile tmpDownload, DownloadOperation download) { try { SemaphoreSlim.Wait(CancelSource.Token); StorageFile plaintextFile = await ApplicationData.Current.LocalCacheFolder.CreateFileAsync(@"Attachments\" + attachment.Id + ".plain", CreationCollisionOption.ReplaceExisting); using (var tmpFileStream = (await tmpDownload.OpenAsync(FileAccessMode.ReadWrite)).AsStream()) using (var plaintextFileStream = (await plaintextFile.OpenAsync(FileAccessMode.ReadWrite)).AsStream()) { Logger.LogInformation("Decrypting to {0}\\{1}", plaintextFile.Path, plaintextFile.Name); DecryptAttachment(attachment.ToAttachmentPointer(), tmpFileStream, plaintextFileStream); } Logger.LogInformation("Deleting tmpFile {0}", tmpDownload.Name); await tmpDownload.DeleteAsync(); attachment.Status = SignalAttachmentStatus.Finished; SignalDBContext.UpdateAttachmentStatus(attachment); await DispatchAttachmentStatusChanged(download, attachment); } catch (Exception e) { Logger.LogError("HandleSuccessfullDownload failed: {0}\n{1}", e.Message, e.StackTrace); } finally { if (Downloads.ContainsKey(attachment.Id)) { Downloads.Remove(attachment.Id); } SemaphoreSlim.Release(); } }
public IAsyncAction SaveSnapshotAsync(SnapshotData data) { byte[] pixeldata = data.data; int pitch = data.pitch; Func <Task> helper = async() => { if (this.currentROM == null) { return; } int pixelWidth = pitch / 4; int pixelHeight = (int)pixeldata.Length / pitch; IStorageFile file = await this.GetFileUsingExtension(".png", true); using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream); encoder.SetPixelData( BitmapPixelFormat.Rgba8, BitmapAlphaMode.Ignore, (uint)pixelWidth, (uint)pixelHeight, 96.0, 96.0, pixeldata); await encoder.FlushAsync(); } await this.RefreshROMListAsync(); }; return(helper().AsAsyncAction()); }
private async Task <string> ComputeMD5(IStorageFile file) { string res = string.Empty; using (var streamReader = await file.OpenAsync(FileAccessMode.Read)) { var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5); var algHash = alg.CreateHash(); using (BinaryReader reader = new BinaryReader(streamReader.AsStream())) { byte[] chunk; chunk = reader.ReadBytes(CHUNK_SIZE); while (chunk.Length > 0) { algHash.Append(CryptographicBuffer.CreateFromByteArray(chunk)); chunk = reader.ReadBytes(CHUNK_SIZE); } } res = CryptographicBuffer.EncodeToHexString(algHash.GetValueAndReset()); return(res); } }
public static async Task <SafeWrapperResult> CopyFileAsync(IStorageFile source, IStorageFile destination, Action <float> progressReportDelegate, CancellationToken cancellationToken) { long fileSize = await StorageHelpers.GetFileSize(source); byte[] buffer = new byte[Constants.FileSystem.COPY_FILE_BUFFER_SIZE]; SafeWrapperResult result = SafeWrapperResult.S_SUCCESS; using (Stream sourceStream = (await source.OpenReadAsync()).AsStreamForRead()) { using (Stream destinationStream = (await destination.OpenAsync(FileAccessMode.ReadWrite)).AsStreamForWrite()) { long bytesTransferred = 0L; int currentBlockSize = 0; while ((currentBlockSize = await sourceStream.ReadAsync(buffer, 0, buffer.Length)) > 0) { bytesTransferred += currentBlockSize; float percentage = (float)bytesTransferred * 100.0f / (float)fileSize; await destinationStream.WriteAsync(buffer, 0, currentBlockSize); progressReportDelegate?.Invoke(percentage); if (cancellationToken.IsCancellationRequested) { // TODO: Delete copied file there result = SafeWrapperResult.S_CANCEL; break; } } } } return(result); }
/// <summary> /// The save to file. /// </summary> /// <param name="writeableBitmap"> /// The writeable bitmap. /// </param> /// <param name="outputFile"> /// The output file. /// </param> /// <returns> /// The <see cref="Task"/>. /// </returns> private async Task SaveToFile(WriteableBitmap writeableBitmap, IStorageFile outputFile) { try { var stream = writeableBitmap.PixelBuffer.AsStream(); var pixels = new byte[(uint)stream.Length]; await stream.ReadAsync(pixels, 0, pixels.Length); using (var streamOut = await outputFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, streamOut); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, (uint)writeableBitmap.PixelWidth, (uint)writeableBitmap.PixelHeight, 96, 96, pixels); await encoder.FlushAsync(); using (var outputStream = streamOut.GetOutputStreamAt(0)) { await outputStream.FlushAsync(); } } } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
async public void OnCapturesCommand(object param) { MediaCapture takePhotoManager = new MediaCapture(); await takePhotoManager.InitializeAsync(); ImageEncodingProperties imgFormat = ImageEncodingProperties.CreateJpeg(); IStorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync( "Photo.jpg", CreationCollisionOption.GenerateUniqueName); await takePhotoManager.CapturePhotoToStorageFileAsync(imgFormat, file); //Windows.Storage.StorageFile file = await cameraUI.CaptureFileAsync(CameraCaptureUIMode.PhotoOrVideo); if (file != null) { IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); BitmapImage bitmap = new BitmapImage(); bitmap.SetSource(fileStream); IGraphInfo graph = this.Info as IGraphInfo; NodeVM node = new NodeVM(); node.OffsetX = ((this.Info as IGraph).ScrollSettings.ScrollInfo.ViewportWidth) / 2; node.OffsetY = ((this.Info as IGraph).ScrollSettings.ScrollInfo.ViewportHeight) / 2; node.UnitHeight = 100; node.UnitWidth = 100; node.Content = new Image() { Source = bitmap, Stretch = Stretch.Fill }; (Nodes as ObservableCollection <NodeVM>).Add(node); } }
private async Task <PDFDoc> OpenFilePDFViewer(IStorageFile file, FileAccessMode mode) { if (file == null) { return(null); } Windows.Storage.Streams.IRandomAccessStream stream; try { stream = await file.OpenAsync(mode); } catch (Exception e) { // NOTE: If file already opened it will cause an exception var msg = new MessageDialog(e.Message); _ = msg.ShowAsync(); return(null); } PDFDoc doc = new PDFDoc(stream); doc.InitSecurityHandler(); return(doc); }
public static async Task SaveToFile( this WriteableBitmap writeableBitmap, IStorageFile outputFile, Guid encoderId) { try { Stream stream = writeableBitmap.PixelBuffer.AsStream(); byte[] pixels = new byte[(uint)stream.Length]; await stream.ReadAsync(pixels, 0, pixels.Length); using (var writeStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(encoderId, writeStream); encoder.SetPixelData( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)writeableBitmap.PixelWidth, (uint)writeableBitmap.PixelHeight, 96, 96, pixels); await encoder.FlushAsync(); using (var outputStream = writeStream.GetOutputStreamAt(0)) { await outputStream.FlushAsync(); } } } catch (Exception ex) { string s = ex.ToString(); } }
/// <summary> /// /// </summary> /// <param name="writeableBitmap"></param> /// <param name="outputFile"></param> /// <param name="encoderId"></param> /// <returns></returns> public static async Task SaveToFile(this WriteableBitmap writeableBitmap, IStorageFile outputFile, Guid encoderId) { try { Stream stream = writeableBitmap.PixelBuffer.AsStream(); byte[] pixels = new byte[(uint)stream.Length]; await stream.ReadAsync(pixels, 0, pixels.Length); using (var writeStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(encoderId, writeStream); encoder.SetPixelData( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)writeableBitmap.PixelWidth, (uint)writeableBitmap.PixelHeight, 96, 96, pixels); await encoder.FlushAsync(); using (var outputStream = writeStream.GetOutputStreamAt(0)) { await outputStream.FlushAsync(); } } } catch (Exception ex) { string s = ex.ToString(); } }
private async Task <bool> UploadFile(IStorageFile localFile, string path) { var result = false; var cts = new CancellationTokenSource(); CachedFileManager.DeferUpdates(localFile); try { using (var stream = await localFile.OpenAsync(FileAccessMode.Read)) { var targetStream = stream.AsStreamForRead(); IProgress <WebDavProgress> progress = new Progress <WebDavProgress>(ProgressHandler); result = await _client.Upload(path, targetStream, localFile.ContentType, progress, cts.Token); } } catch (ResponseError e2) { ResponseErrorHandlerService.HandleException(e2); } // Let Windows know that we're finished changing the file so // the other app can update the remote version of the file. // Completing updates may require Windows to ask for user input. await CachedFileManager.CompleteUpdatesAsync(localFile); return(result); }
public static async Task<FlacMediaSourceAdapter> CreateAsync(IStorageFile file) { var fileStream = await file.OpenAsync(FileAccessMode.Read); var adapter = new FlacMediaSourceAdapter(); adapter.Initialize(fileStream); return adapter; }
public FileItemToShare(String fileName, String filePath, IStorageFile fileToShare) { this.m_FileName = fileName; this.m_FilePath = filePath; this.FileSize = fileToShare.OpenAsync(FileAccessMode.Read).AsTask().Result.Size; this.m_File = fileToShare; m_FileShareStatus = FileShareStatus.Waiting; }
public async void DisplayFrame() { if (Sleeping) { Debug.WriteLine(@"Fake Module sleeping, I'll do nothing"); return; } if (_image != null) { /* Generate gray image */ byte[] generatedImage = new byte[4 * Width * Height]; for (int i = 0; i < Width * Height; ++i) { if ((buffer[i / 8] & (0x80 >> (i % 8))) == 0) { generatedImage[4 * i] = 0; generatedImage[4 * i + 1] = 0; generatedImage[4 * i + 2] = 0; generatedImage[4 * i + 3] = 255; } else { generatedImage[4 * i] = 255; generatedImage[4 * i + 1] = 255; generatedImage[4 * i + 2] = 255; generatedImage[4 * i + 3] = 255; } } IStorageFolder applicationfolder = ApplicationData.Current.LocalFolder; Debug.WriteLine(applicationfolder.Path); IStorageFile saveFile = await applicationfolder.CreateFileAsync("test.png", CreationCollisionOption.ReplaceExisting); using (var fileStream = await saveFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, fileStream); encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Ignore, (uint)Width, (uint)Height, 75, 75, generatedImage.ToArray()); await encoder.FlushAsync(); } /* Create a bitmap source */ Stream s = await applicationfolder.OpenStreamForReadAsync("test.png"); BitmapImage imageSource = new BitmapImage(); await imageSource.SetSourceAsync(s.AsRandomAccessStream()); BitmapImage One = new BitmapImage(new Uri("ms-appx:///Assets/StoreLogo.png")); /* Update image to the control */ _image.Source = imageSource; _image.Width = Width; _image.Height = Height; } }
public async void Save_as(IStorageFile file, Excuse excuseToWrite) { using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite)) using(Stream outputStream = stream.AsStreamForWrite()) { DataContractSerializer serializer = new DataContractSerializer(typeof(Excuse)); serializer.WriteObject(outputStream, excuseToWrite); } OnPropertyChanged("excuseToWrite"); }
public static async Task <FlacMediaSourceAdapter> CreateAsync(IStorageFile file) { var fileStream = await file.OpenAsync(FileAccessMode.Read); var adapter = new FlacMediaSourceAdapter(); adapter.Initialize(fileStream); return(adapter); }
//public static async Task SaveXmlFile(IStorageFile file) //{ // await SaveXElement(null, file); //} private static async Task SaveXElement(XElement elem, IStorageFile file) { var doc = new XDocument(new XDeclaration("1.0", "utf-8", "yes")); doc.Add(elem); using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { doc.Save(stream.AsStreamForWrite()); } }
private async Task LoadIconAsync(IStorageFile file) { using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapImage bitmapImage = new BitmapImage(); await bitmapImage.SetSourceAsync(fileStream); Icon = bitmapImage; } }
private async void SaveSoftwareBitmapToFile(SoftwareBitmap softwareBitmap, IStorageFile outputFile) { using (var stream = await outputFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream); encoder.SetSoftwareBitmap(softwareBitmap); await encoder.FlushAsync(); } }
public static async Task <BitmapImage> ConvertStorageToImage(IStorageFile savedStorageFile) { using (IRandomAccessStream fileStream = await savedStorageFile.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapImage bitmapImage = new BitmapImage(); await bitmapImage.SetSourceAsync(fileStream); return(bitmapImage); } }
public static async Task <T> Deserialize <T>(IStorageFile file) { T val; using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read)) { XmlSerializer xs = new XmlSerializer(typeof(T)); val = (T)xs.Deserialize(stream.AsStreamForRead()); } return(val); }
public async Task<Excuse> OpenFile(IStorageFile file, Excuse excuseToRead) { using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read)) using(Stream inputStream = stream.AsStreamForRead()) { DataContractSerializer serializer = new DataContractSerializer(typeof(Excuse)); excuseToRead = serializer.ReadObject(inputStream) as Excuse; } return excuseToRead; }
public static async Task<BitmapImage> GetImageFromFileAsync(IStorageFile file) { IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); // Set the image source to the selected bitmap. BitmapImage bitmapImage = new BitmapImage(); bitmapImage.SetSource(fileStream); return bitmapImage; }
public static async Task<byte[]> ReadFromFile(IStorageFile file) { var stream = await file.OpenAsync(FileAccessMode.Read); var reader = new DataReader(stream.GetInputStreamAt(0)); var streamSize = (uint) stream.Size; await reader.LoadAsync(streamSize); var buffer = new byte[streamSize]; reader.ReadBytes(buffer); return buffer; }
private static async Task <SoftwareBitmap> ConvertToSoftwareBitmap(IStorageFile file) { using (var stream = await file.OpenAsync(FileAccessMode.Read)) { var decoder = await BitmapDecoder.CreateAsync(stream); var softwareBitmap = await decoder.GetSoftwareBitmapAsync(); return(SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied)); } }
public static async Task <TagLib.File.IFileAbstraction> CreateAsync(IStorageFile file) { var fAbs = new UwpFileAbstraction(); fAbs.Name = file.Path; var ras = await file.OpenAsync(FileAccessMode.Read); fAbs.ReadStream = ras.AsStream(); return(fAbs); }
public async Task LoadPwDatabase(IStorageFile pwDatabaseFile, IList<IUserKey> userKeys, IProgress<double> percentComplete) { StorageFile = pwDatabaseFile; var factory = new KdbReaderFactory(_encryptionEngine, _keyTransformer, _hasher, _gzipStreamFactory); var file = await pwDatabaseFile.OpenAsync(FileAccessMode.Read); Stream kdbDataReader = file.AsStream(); this.PwDatabase = await factory.LoadAsync(kdbDataReader, userKeys, percentComplete); }
public async void ReadGuyAsync() { if (String.IsNullOrEmpty(Path)) return; latestGuyFile = await StorageFile.GetFileFromPathAsync(Path); using (IRandomAccessStream stream = await latestGuyFile.OpenAsync(FileAccessMode.Read)) using (Stream inputStream = stream.AsStreamForRead()) { DataContractSerializer serializer = new DataContractSerializer(typeof(Guy)); NewGuy = serializer.ReadObject(inputStream) as Guy; } OnPropertyChanged("NewGuy"); OnPropertyChanged("LatestGuyFile"); }
/// <summary> /// Reads the contents of the specified file and returns text. /// </summary> /// <param name="file">The file to read.</param> public static async Task<string> ReadTextAsync(IStorageFile file) { using (var fs = await file.OpenAsync(FileAccessMode.Read)) { using (var inStream = fs.GetInputStreamAt(0)) { using (var reader = new DataReader(inStream)) { await reader.LoadAsync((uint)fs.Size); string data = reader.ReadString((uint)fs.Size); reader.DetachStream(); return data; } } } }
/// <summary> /// Saves the given <see cref="WriteableBitmap" /> to a specified storage file. /// </summary> /// <param name="writeableBitmap">The writeable bitmap.</param> /// <param name="storageFile">The storage file.</param> public static async Task SaveToStorageFile(this WriteableBitmap writeableBitmap, IStorageFile storageFile) { using (var writestream = await storageFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, writestream); using (var pixelStream = writeableBitmap.PixelBuffer.AsStream()) { var pixels = new byte[pixelStream.Length]; await pixelStream.ReadAsync(pixels, 0, pixels.Length); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)writeableBitmap.PixelWidth, (uint)writeableBitmap.PixelHeight, 96.0, 96.0, pixels); await encoder.FlushAsync(); } } }
/// <summary> /// Writes text to the specified file. /// </summary> /// <param name="file">The file that the text is written to.</param> /// <param name="contents">The text to write.</param> public static async Task WriteTextAsync(IStorageFile file, string contents) { using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var outStream = fs.GetOutputStreamAt(0)) { using (var dataWriter = new DataWriter(outStream)) { if (contents != null) { dataWriter.WriteString(contents); } await dataWriter.StoreAsync(); dataWriter.DetachStream(); } await outStream.FlushAsync(); } } }
internal static async Task ResizeAndSaveAs(IStorageFile source, IStorageFile destination, int targetDimension) { // open the file... using(var sourceStream = await source.OpenReadAsync()) { // step one, get a decoder... var decoder = await BitmapDecoder.CreateAsync(sourceStream); // step two, create somewhere to put it... using(var destinationStream = await destination.OpenAsync(FileAccessMode.ReadWrite)) { // step three, create an encoder... var encoder = await BitmapEncoder.CreateForTranscodingAsync(destinationStream, decoder); // how big is it? uint width = decoder.PixelWidth; uint height = decoder.PixelHeight; decimal ratio = (decimal)width / (decimal)height; // orientation? bool portrait = width < height; // step four, configure it... if (portrait) { encoder.BitmapTransform.ScaledHeight = (uint)targetDimension; encoder.BitmapTransform.ScaledWidth = (uint)((decimal)targetDimension * ratio); } else { encoder.BitmapTransform.ScaledWidth = (uint)targetDimension; encoder.BitmapTransform.ScaledHeight = (uint)((decimal)targetDimension / ratio); } // step five, write it... await encoder.FlushAsync(); } } }
public async void WriteGuyAsync(Guy guyToWrite) { IStorageFolder guysFolder = await KnownFolders.DocumentsLibrary.CreateFolderAsync("Guys", CreationCollisionOption.OpenIfExists); latestGuyFile = await guysFolder.CreateFileAsync(guyToWrite.Name + ".xml", CreationCollisionOption.ReplaceExisting); using (IRandomAccessStream stream = await latestGuyFile.OpenAsync(FileAccessMode.ReadWrite)) using (Stream outputStream = stream.AsStreamForWrite()) { DataContractSerializer serializer = new DataContractSerializer(typeof(Guy)); serializer.WriteObject(outputStream, guyToWrite); } Path = latestGuyFile.Path; OnPropertyChanged("Path"); OnPropertyChanged("LatestGuyFile"); }
private async Task<Image> CreateImageFromStorageFileAsync(IStorageFile file) { var image = new Image(); using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read)) { BitmapImage bitmapImage = new BitmapImage(); await bitmapImage.SetSourceAsync(fileStream); image.Source = bitmapImage; } return image; }
private static async Task<BitmapImage> LoadImage(IStorageFile file) { var bitmapImage = new BitmapImage(); var stream = (FileRandomAccessStream)await file.OpenAsync(FileAccessMode.Read); bitmapImage.SetSource(stream); return bitmapImage; }
/// <summary> /// Checks if the current timetable image has the wrong dimensions. /// </summary> /// <param name="canvasHeight">Height of the <c>canvas</c></param> /// <param name="timetableFile"> /// <c>Timetable image</c> /// </param> /// <returns><c>True</c> if a new timetable needs to be downloaded; <c>False</c> if not.</returns> private static async Task<bool> CheckIfBadDimensions(double canvasHeight, IStorageFile timetableFile) { bool downloadNew = false; //Bitmap decoder to read width and height from PNG. BitmapDecoder bitmapDecoder = null; try { //Open the file async using (IRandomAccessStream stream = await timetableFile.OpenAsync(FileAccessMode.Read)) { bitmapDecoder = await BitmapDecoder.CreateAsync(stream); } } //Sometimes do not work, can't figure out what the problem is. This "catch" helps me avoid crashes. catch (Exception) { // ignored } if (bitmapDecoder != null) { //If the image does not have the same height as the canvas, then download new one if (bitmapDecoder.PixelHeight != canvasHeight) { downloadNew = true; } } //if our Try Catch failed, then just download new image either way. else { downloadNew = true; } return downloadNew; }