public static CueFile CreateFromStream(IRandomAccessStream stream, bool autodetectEncoding) { if (stream.Size > MaxCueFileSize) { // Return empty list when file size exceeds the limit. return(new CueFile("", new List <ManagedAudioIndexCue>())); } if (!autodetectEncoding) { using (var mstream = stream.AsStreamForRead()) using (var sr = new StreamReader(mstream)) return(CreateFromString(sr.ReadToEnd())); } else { using (var mstream = stream.AsStreamForRead()) { int length = (int)mstream.Length; byte[] bytes = new byte[length]; mstream.Read(bytes, 0, length); var charset = Text.Chardet.DetectCodepage(bytes); var encoding = Encoding.GetEncoding(charset); if (encoding == null) { encoding = Encoding.UTF8; } return(CreateFromString(encoding.GetString(bytes))); } } }
public static async Task <IBuffer> StreamToBuffer(IRandomAccessStream stream) { var s = stream.AsStreamForRead(); if (stream != null) { s = stream.AsStreamForRead(); int len = (int)s.Length; byte[] b = new byte[(uint)s.Length]; await s.ReadAsync(b, 0, len); IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(b, 0, len); return(buffer); } return(null); }
public static async Task CreateAndWriteToFileAsync(IRandomAccessStream contentStream, string path) { CreateParentDirectories(path); await using var stream = File.Open(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None); contentStream.Seek(0); await contentStream.AsStreamForRead().CopyToAsync(stream); }
/// <summary> /// ZIPデータを読み込みファイル一覧を作成する /// </summary> /// <returns></returns> public async Task LoadDataAsync() { this.Dispose(); this.m_dataList.Clear(); StorageFile zipFile = await StorageFile.GetFileFromPathAsync(m_imageParam.Path); StorageHistoryManager.AddStorage(zipFile, StorageHistoryManager.DataType.Latest); this.ParentStorage = zipFile; IRandomAccessStream randomStream = await zipFile.OpenReadAsync(); Stream stream = randomStream.AsStreamForRead(); m_zipArchive = new ZipArchive(stream); foreach (ZipArchiveEntry entry in m_zipArchive.Entries) { if (FileKind.IsImageFile(entry.FullName)) { m_dataList.Add(entry); } } sortList(m_dataList); //名前の順に並び替え foreach (ZipArchiveEntry entry in m_dataList) { Debug.WriteLine(entry.Name); } }
public async Task <Stream> Encode() { try { Stopwatch stopwatchEncode = new Stopwatch(); stopwatchEncode.Start(); IRandomAccessStream imageStream = (IRandomAccessStream) new InMemoryRandomAccessStream(); BitmapEncoder bitmapEncoder = await GraffitiEncoder.BuildEncoder(imageStream); BitmapPixelFormat pixelFormat; byte[] imageBinaryData1 = GraffitiEncoder.GetImageBinaryData1(this._bitmap, out pixelFormat); int num1 = (int)pixelFormat; int num2 = 0; int pixelWidth = this._bitmap.PixelWidth; int pixelHeight = this._bitmap.PixelHeight; double dpiX = 72.0; double dpiY = 72.0; byte[] pixels = imageBinaryData1; bitmapEncoder.SetPixelData((BitmapPixelFormat)num1, (BitmapAlphaMode)num2, (uint)pixelWidth, (uint)pixelHeight, dpiX, dpiY, pixels); await bitmapEncoder.FlushAsync().AsTask().ConfigureAwait(false); long num3 = (long)imageStream.Size; stopwatchEncode.Stop(); Execute.ExecuteOnUIThread((Action)(() => {})); return(imageStream.AsStreamForRead()); } catch { return((Stream)null); } }
public static async Task <List <Kategoria> > Import(StorageFile _fajl) { XLWorkbook wb = null; using (IRandomAccessStream s = await _fajl.OpenReadAsync()) wb = new XLWorkbook(s.AsStreamForRead()); IXLWorksheet ws = wb.Worksheet("Categories"); List <Kategoria> kategoriak = new List <Kategoria>(); foreach (var sor in ws.RangeUsed().RowsUsed()) { if (sor.RowNumber() == 1) { continue; } Kategoria kategoria = new Kategoria() { ID = sor.Cell(1).GetValue <int>(), ParentID = sor.Cell(2).GetValue <int>(), Megnevezes = sor.Cell(4).GetString() }; kategoriak.Add(kategoria); } return(kategoriak); }
public void UpdateImage(IRandomAccessStream rass) { storage["Picture"] = new ParseFile("Picture.jpg", rass.AsStreamForRead()); this.RaisePropertyChanged("Picture"); }
/// <summary> /// Load a given filename asynchronously /// </summary> /// <param name="fileName"></param> /// <returns></returns> public async Task <T> LoadAsync(string fileName) { try { fileName = AppendExt(fileName); StorageFile file = null; file = await storageFolder.GetFileAsync(fileName); IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read); Stream inStream = Task.Run(() => readStream.AsStreamForRead()).Result; return((T)xmlSerializer.Deserialize(inStream)); } catch (FileNotFoundException) { //file not existing is perfectly valid so simply return the default return(default(T)); //throw; } catch (Exception) { //Unable to load contents of file throw; } }
public async Task ReadExcuseAsync() { try { using (IRandomAccessStream stream = await excuseFile.OpenAsync(FileAccessMode.Read)) using (Stream inputStream = stream.AsStreamForRead()) { DataContractSerializer serializer = new DataContractSerializer(typeof(Excuse)); CurrentExcuse = serializer.ReadObject(inputStream) as Excuse; } await new MessageDialog("Excuse read from to " + excuseFile.Name).ShowAsync(); await UpdateFileDateAsync(); } catch (SerializationException) { new MessageDialog("Unable to read " + excuseFile.Name).ShowAsync(); NewExcuseAsync(); } finally { OnPropertyChanged("CurrentExcuse"); } }
/// <summary> /// Chargement du contenu du fichier XML contenant /// les scores des joueurs dans une collection de joueurs /// </summary> public async void charger() { var localFolder = ApplicationData.Current.LocalFolder; XDocument doc = new XDocument(); try { StorageFile textFile = await localFolder.GetFileAsync("scores.xml"); using (IRandomAccessStream textStream = await textFile.OpenReadAsync()) { Stream s = textStream.AsStreamForRead(); doc = XDocument.Load(s); int nbJoueurs = doc.Root.Elements().Count(); var joueurs = doc.Descendants("Joueur"); foreach (var joueur in joueurs) { string pseudo = joueur.Element("pseudo").Value; int score = int.Parse(joueur.Element("score").Value); Joueur leJoueur = new Joueur(); leJoueur.pseudo = pseudo; leJoueur.score = score; tabScores.Add(leJoueur); } tabScores.Sort(); } } catch { } }
public static async Task <T> readObjektAsync <T>(string datei) { StorageFile file; IRandomAccessStream inStream = null; try { file = await ApplicationData.Current.LocalFolder.GetFileAsync(datei); inStream = await file.OpenAsync(FileAccessMode.Read); DataContractSerializer serializer = new DataContractSerializer(typeof(T)); var data = (T)serializer.ReadObject(inStream.AsStreamForRead()); inStream.Dispose(); return(data); } catch (Exception) { if (inStream != null) { inStream.Dispose(); } return(default(T)); } }
/// <summary> /// Load object from file /// </summary> /// <param name="fileName"></param> /// <returns></returns> public async Task <T> LoadAsync(string fileName) { fileName = fileName + FileExtension; StorageFolder folder = await GetFolderAsync().ConfigureAwait(false); if (await folder.ContainsFileAsync(fileName).ConfigureAwait(false)) { StorageFile file = await folder.GetFileAsync(fileName); string data; IRandomAccessStream accessStream = await file.OpenReadAsync(); if (accessStream.Size == 0) { return(default(T)); } using (Stream stream = accessStream.AsStreamForRead((int)accessStream.Size)) { var content = new byte[stream.Length]; await stream.ReadAsync(content, 0, (int)stream.Length).ConfigureAwait(false); data = Encoding.UTF8.GetString(content, 0, content.Length); } //Deserialize to object var result = JsonConvert.DeserializeObject <T>(data); return(result); } return(default(T)); }
public async Task LoadKHRSpecGlossGLTFFromStreamUWP() { StorageFolder localFolder = ApplicationData.Current.LocalFolder; StorageFile sampleFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(GLTF_PBR_SPECGLOSS_PATH)); IRandomAccessStream gltfStream = await sampleFile.OpenAsync(FileAccessMode.Read); var reader = new DataReader(gltfStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)gltfStream.Size); GLTFRoot gltfRoot = GLTFParser.ParseJson(gltfStream.AsStreamForRead()); Assert.IsNotNull(gltfRoot.ExtensionsUsed); Assert.IsTrue(gltfRoot.ExtensionsUsed.Contains(KHR_materials_pbrSpecularGlossinessExtensionFactory.EXTENSION_NAME)); Assert.IsNotNull(gltfRoot.Materials); Assert.AreEqual(1, gltfRoot.Materials.Count); Material materialDef = gltfRoot.Materials[0]; KHR_materials_pbrSpecularGlossinessExtension specGloss = materialDef.Extensions[KHR_materials_pbrSpecularGlossinessExtensionFactory.EXTENSION_NAME] as KHR_materials_pbrSpecularGlossinessExtension; Assert.IsTrue(specGloss != null); Assert.AreEqual(Color.White, specGloss.DiffuseFactor); Assert.AreEqual(4, specGloss.DiffuseTexture.Index.Id); Assert.AreEqual(KHR_materials_pbrSpecularGlossinessExtension.SPEC_FACTOR_DEFAULT, specGloss.SpecularFactor); Assert.AreEqual(KHR_materials_pbrSpecularGlossinessExtension.GLOSS_FACTOR_DEFAULT, specGloss.GlossinessFactor); Assert.AreEqual(5, specGloss.SpecularGlossinessTexture.Index.Id); }
private async Task <SavedData> retrieveSavedData() { SavedData savedData = new SavedData(); XmlSerializer xmlSerializer = new XmlSerializer(typeof(SavedData)); try { StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(savedDataFileName); using (IRandomAccessStream writeStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { if (writeStream.Size != 0) { using (XmlReader xmlReader = XmlReader.Create(writeStream.AsStreamForRead())) { savedData = xmlSerializer.Deserialize(xmlReader) as SavedData; if (savedData == null) { savedData = new SavedData(); } } } } } catch (FileNotFoundException) { // EAT: The save game file doesn't exist, so a new one will be made later } return(savedData); }
/// <summary> /// 读取本地文件夹根目录的文件 /// </summary> /// <param name="fileName">文件名</param> /// <returns>读取文件的内容</returns> public static async Task <string> ReadFileAsync(string fileName) { string text; try { // 获取存储数据的文件夹 IStorageFolder applicationFolder = await GetDataFolder(); // 根据文件名获取文件夹里面的文件 IStorageFile storageFile = await applicationFolder.GetFileAsync(fileName); // 打开文件获取文件的数据流 IRandomAccessStream accessStream = await storageFile.OpenReadAsync(); // 使用StreamReader读取文件的内容,需要将IRandomAccessStream对象转化为Stream对象来初始化StreamReader对象 using (StreamReader streamReader = new StreamReader(accessStream.AsStreamForRead((int)accessStream.Size))) { text = streamReader.ReadToEnd(); } } catch (Exception e) { text = "文件读取错误:" + e.Message; } return(text); }
public async Task<IRandomAccessStream> GetThumbnailImage(IRandomAccessStream stream, int width, int height, bool smartCropping = true) { var response = await _client.GetThumbnailAsync(stream.AsStreamForRead(), width, height, smartCropping); var responseStream = new MemoryStream(response); return responseStream.AsRandomAccessStream(); }
public static async Task<ImgurEntity> UploadImgur(IRandomAccessStream fileStream) { try { var imageData = new byte[fileStream.Size]; for (int i = 0; i < imageData.Length; i++) { imageData[i] = (byte)fileStream.AsStreamForRead().ReadByte(); } var theAuthClient = new HttpClient(); var request = new HttpRequestMessage(HttpMethod.Post, "https://api.imgur.com/3/image"); request.Headers.Authorization = new AuthenticationHeaderValue("Client-ID", "e5c018ac1f4c157"); var form = new MultipartFormDataContent(); var t = new StreamContent(fileStream.AsStream()); // TODO: See if this is the correct way to use imgur's v3 api. I can't see why we would still need to convert images to base64. string base64Img = Convert.ToBase64String(imageData); t.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg"); form.Add(new StringContent(base64Img), @"image"); form.Add(new StringContent("file"), "type"); request.Content = form; HttpResponseMessage response = await theAuthClient.SendAsync(request); string responseString = await response.Content.ReadAsStringAsync(); if (responseString == null) return null; var imgurEntity = JsonConvert.DeserializeObject<ImgurEntity>(responseString); return imgurEntity; } catch (WebException) { } catch (IOException) { return null; } return null; }
public async Task <string> CreateMusicAlbumCoverFile(string name, IRandomAccessStream stream) { if (string.IsNullOrEmpty(name)) { throw new ArgumentException($"“{nameof(name)}”不能为 null 或空。", nameof(name)); } if (stream is null) { throw new ArgumentNullException(nameof(stream)); } string fileName = name.Replace(":", string.Empty).Replace("/", string.Empty).Replace("\\", string.Empty).Replace("?", string.Empty).Replace("*", string.Empty).Replace("|", string.Empty).Replace("\"", string.Empty).Replace("<", string.Empty).Replace(">", string.Empty); StorageFolder folder = ApplicationData.Current.TemporaryFolder; if (await folder.FileExistsAsync($"{fileName}.png")) { return((await folder.GetFileAsync($"{fileName}.png")).Path); } StorageFile file = await folder.CreateFileAsync($"{fileName}.png", CreationCollisionOption.OpenIfExists); Stream fileStream = (await file.OpenAsync(FileAccessMode.ReadWrite)).AsStreamForWrite(); Stream _stream = stream.AsStreamForRead(); _ = _stream.Seek(0, SeekOrigin.Begin); await _stream.CopyToAsync(fileStream); await fileStream.FlushAsync(); fileStream.Dispose(); return(file.Path); }
public void TakePicture(int maxPixelDimension, int percentQuality, Action <Stream> pictureAvailable, Action assumeCancelled) { var dispatcher = this.GetService <IMvxViewDispatcherProvider>(); dispatcher.Dispatcher.RequestMainThreadAction( async() => { // Using Windows.Media.Capture.CameraCaptureUI API to capture a photo var dialog = new CameraCaptureUI(); var aspectRatio = new Size(16, 9); dialog.PhotoSettings.CroppedAspectRatio = aspectRatio; // HACK HACK! dialog.PhotoSettings.MaxResolution = CameraCaptureUIMaxPhotoResolution.SmallVga; dialog.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg; var file = await dialog.CaptureFileAsync(CameraCaptureUIMode.Photo); if (file != null) { BitmapImage bitmapImage = new BitmapImage(); var memoryStream = new MemoryStream(); using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read)) { var conventional = fileStream.AsStreamForRead(); conventional.CopyTo(memoryStream); } pictureAvailable(memoryStream); } else { assumeCancelled(); } }); }
/// <summary> /// Retrieve a stored instance of T with a specified handle from Windows.Storage.ApplicationData. /// Specification of a handle supports storage and deletion of different instances of T. /// </summary> /// <param name="Handle">User-defined handle for the stored object</param> public async Task <T> LoadAsync(string Handle) { if (Handle == null) { throw new ArgumentNullException("Handle"); } string fileName = FileName(Activator.CreateInstance <T>(), Handle); try { StorageFile file = null; StorageFolder folder = GetFolder(storageType); file = await folder.GetFileAsync(fileName); IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read); using (Stream inStream = Task.Run(() => readStream.AsStreamForRead()).Result) { return((T)serializer.Deserialize(inStream)); } } catch (FileNotFoundException) { //file not existing is perfectly valid so simply return the default return(default(T)); //Interesting thread here: How to detect if a file exists (http://social.msdn.microsoft.com/Forums/en-US/winappswithcsharp/thread/1eb71a80-c59c-4146-aeb6-fefd69f4b4bb) //throw; } catch (Exception) { //Unable to load contents of file throw; } }
//</SnippetVertices> /// <summary> /// Fixes issue in API where textures are not saved correctly /// </summary> /// <param name="modelStream">3dmodel.model data</param> /// <returns></returns> private async Task <IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream) { XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead()); var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var writer = new Windows.Storage.Streams.DataWriter(outputStream); writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; writer.WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); var text = xmldoc.ToString(); // ensure that content type is set correctly // texture content can be either png or jpg var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\""); writer.WriteString(replacedText); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); return(outputStream); }
public WindowsUniversalFileStream(string fileName, StorageFolder directory, FileAccessMode mode, CreationCollisionOption collisionOptions, StorageOpenOptions openOptions, int length = 1024 * 80, int writeBufferSize = 1024 * 80, int readBufferSize = 1024 * 80) { if (fileName == null || fileName == string.Empty) { throw new ArgumentNullException("path"); } Directory = directory; FileName = fileName; Mode = mode; CollisionOptions = collisionOptions; OpenOptions = openOptions; WriteBufferSize = writeBufferSize; ReadBufferSize = readBufferSize; RandomAccessStream = Directory.CreateFileAsync(FileName, collisionOptions).AsTask().Result.OpenAsync(mode, openOptions).AsTask().Result; ReadStream = RandomAccessStream.AsStreamForRead(ReadBufferSize); ReadStream.SetLength(length); if (mode == FileAccessMode.ReadWrite) { WriteStream = RandomAccessStream.AsStreamForWrite(WriteBufferSize); } }
/// <summary> /// アーカイブファイルからサムネイル用画像データを取得する /// </summary> /// <param name="path"></param> /// <param name="thumWidth"></param> /// <returns></returns> public static async Task <BitmapImage> GetFirstImageFromArchive(string path, int thumWidth) { BitmapImage bitmap = null; StorageFile zipFile = await StorageFile.GetFileFromPathAsync(path); using (IRandomAccessStream randomStream = await zipFile.OpenReadAsync()) { using (Stream stream = randomStream.AsStreamForRead()) { using (ZipArchive zipArchive = new ZipArchive(stream)) { foreach (ZipArchiveEntry entry in zipArchive.Entries) { if (FileKind.IsImageFile(entry.FullName)) { bitmap = await BitmapUtils.CreateBitmap(entry, thumWidth); break; } } } } } return(bitmap); }
private async void OnCapturePhotoCompleted(IRandomAccessStream stream, IAsyncAction result, AsyncStatus status) { try { Stream streamCopy = stream.AsStreamForRead(); streamCopy.Position = 0; Face[] faces = await _faceClient.DetectAsync(streamCopy); stream.Dispose(); stream = null; bool userDetected = false; foreach (var face in faces) { VerifyResult verifyResult = await _faceClient.VerifyAsync(face.FaceId, _groupId, _personId); if (userDetected = verifyResult.IsIdentical) { break; } } await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { if (userDetected && !_loggedOn) { txtGreeting.Text = "Hello!"; animGreeting.Begin(); _loggedOn = true; imgLogoff.Visibility = Windows.UI.Xaml.Visibility.Collapsed; imgLogon.Visibility = Windows.UI.Xaml.Visibility.Visible; itmsCalendarEvents.Visibility = Windows.UI.Xaml.Visibility.Visible; } else if (!userDetected && _loggedOn) { txtGreeting.Text = "Goodbye!"; animGreeting.Begin(); _loggedOn = false; imgLogoff.Visibility = Windows.UI.Xaml.Visibility.Visible; imgLogon.Visibility = Windows.UI.Xaml.Visibility.Collapsed; itmsCalendarEvents.Visibility = Windows.UI.Xaml.Visibility.Collapsed; } }); } catch (FaceAPIException e) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { txtException.Text = e.ErrorMessage; animException.Begin(); }); } catch (Exception) { if (stream != null) { stream.Dispose(); stream = null; } } }
public static async Task <string> Sha1Async(this IRandomAccessStream randomAccessStream) { using var sha1 = SHA1.Create(); var result = await sha1.ComputeHashAsync(randomAccessStream.AsStreamForRead()); randomAccessStream.Seek(0); // reset the stream return(result.Select(b => b.ToString("x2")).Aggregate((acc, str) => acc + str)); }
public async Task <IRandomAccessStream> GetThumbnailImage(IRandomAccessStream stream, int width, int height, bool smartCropping = true) { var response = await _client.GetThumbnailAsync(stream.AsStreamForRead(), width, height, smartCropping); var responseStream = new MemoryStream(response); return(responseStream.AsRandomAccessStream()); }
/// <summary> /// Analyzes a bitmap image into a color palette. /// </summary> /// <param name="image">Bitmap Image.</param> /// <param name="width">Width of the image.</param> /// <param name="height">Hight of the image.</param> public async void Analyse(BitmapImage image, int width = 96, int height = 66) { RandomAccessStreamReference random = RandomAccessStreamReference.CreateFromUri(image.UriSource); IRandomAccessStream str = await random.OpenReadAsync(); Analyse(str.AsStreamForRead(), width, height); str.Dispose(); }
/// <inheritdoc/> public async Task <IOneDriveStorageFile> UploadFileAsync(string desiredName, IRandomAccessStream content, CreationCollisionOption options = CreationCollisionOption.FailIfExists, int maxChunkSize = -1) { int currentChunkSize = maxChunkSize < 0 ? OneDriveUploadConstants.DefaultMaxChunkSizeForUploadSession : maxChunkSize; if (currentChunkSize % OneDriveUploadConstants.RequiredChunkSizeIncrementForUploadSession != 0) { throw new ArgumentException("Max chunk size must be a multiple of 320 KiB", nameof(maxChunkSize)); } if (string.IsNullOrEmpty(desiredName)) { throw new ArgumentNullException(nameof(desiredName)); } if (content == null) { throw new ArgumentNullException(nameof(content)); } var uploadSessionUri = $"{Provider.BaseUrl}/drive/items/{OneDriveItem.Id}:/{desiredName}:/oneDrive.createSession"; var conflictBehavior = new OneDriveItemConflictBehavior { Item = new OneDriveConflictItem { ConflictBehavior = OneDriveHelper.TransformCollisionOptionToConflictBehavior(options.ToString()) } }; var jsonConflictBehavior = JsonConvert.SerializeObject(conflictBehavior); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, uploadSessionUri) { Content = new StringContent(jsonConflictBehavior, Encoding.UTF8, "application/json") }; await Provider.AuthenticationProvider.AuthenticateRequestAsync(request).ConfigureAwait(false); var response = await Provider.HttpProvider.SendAsync(request).ConfigureAwait(false); if (!response.IsSuccessStatusCode) { throw new ServiceException(new Error { Message = "Could not create an UploadSession", Code = "NoUploadSession", ThrowSite = "UWP Community Toolkit" }); } IsUploadCompleted = false; var jsonData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); _uploadSession = JsonConvert.DeserializeObject <Microsoft.OneDrive.Sdk.UploadSession>(jsonData); var streamToUpload = content.AsStreamForRead(); _uploadProvider = new Microsoft.OneDrive.Sdk.Helpers.ChunkedUploadProvider(_uploadSession, Provider, streamToUpload, maxChunkSize); var uploadedItem = await _uploadProvider.UploadAsync().ConfigureAwait(false); IsUploadCompleted = true; return(InitializeOneDriveStorageFile(uploadedItem.CopyToDriveItem())); }
/// <summary> /// Constructs a Logo from a WinRT Stream. /// </summary> /// <param name="imageStream">A stream containing a valid image</param> public LogoSource(IRandomAccessStream imageStream) { if (imageStream == null) { throw new ArgumentNullException("imageStream"); } _stream = imageStream.AsStreamForRead(); _ownsStream = true; }
public virtual async void Consume(IRandomAccessStream stream) { using (stream) { using var gifStream = await IOHelper.GetGifStreamFromZipStreamAsync(stream.AsStreamForRead(), _metadata); await IOHelper.CreateAndWriteToFileAsync(gifStream, Destination); } }
public async Task <bool> UploadFileAsync(StorageFile localFile, CancellationToken cancellationToken) { if (!await IsAuthenticatedAsync().ConfigureAwait(false)) { return(false); } try { bool uploadSucceeded = await CoreHelper.RetryAsync(async() => { using (await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false)) using (IRandomAccessStream localFileContent = await localFile.OpenReadAsync()) using (Stream localFileContentStream = localFileContent.AsStreamForRead()) { FileMetadata uploadResult = null; long localFileSize = localFileContentStream.Length; int chunksCount = (int)Math.Ceiling((double)localFileSize / TransferBufferSize); if (chunksCount <= 1) { // File is too small for uploading by chunks. Let's upload in 1 shot. uploadResult = await _dropboxClient.Files.UploadAsync( new CommitInfo( path: "/" + localFile.Name, mode: WriteMode.Overwrite.Instance), localFileContentStream) .ConfigureAwait(false); } else { // For files > 150 MB, UploadAsync won't work, so we use an upload session in case. // It is unlikely that a user data file will be 150 MB but we never know. // In fact, here we use upload session for any file bigger than the TransferBufferSize. uploadResult = await UploadFileInChunksAsync( chunksCount, localFileContentStream, localFile.Name) .ConfigureAwait(false); } return(uploadResult != null && uploadResult.Size == (ulong)localFileSize); } }).ConfigureAwait(false); _logger.LogEvent(UploadFileEvent, $"Upload succeeded == {uploadSucceeded}"); return(uploadSucceeded); } catch (Exception ex) { _logger.LogFault(UploadFileFaultEvent, "Unable to upload a file.", ex); return(false); } }
public static byte[] ReadStreamToByteArray(this IRandomAccessStream oriStream) { var stream = oriStream.AsStreamForRead(); stream.Seek(0, SeekOrigin.Begin); var data = new byte[stream.Length]; stream.Read(data, 0, (int)stream.Length); return(data); }
public static async Task <byte[]> ToByteArray(this IRandomAccessStream accessStream) { var stream = accessStream.AsStreamForRead(); byte[] array = new byte[stream.Length]; await stream.ReadAsync(array, 0, array.Length); return(array); }
public async Task<string> GetPrevalentEmotion(IRandomAccessStream imageStream) { var result = await _client.RecognizeAsync(imageStream.AsStreamForRead()); var emotionScores = typeof(Microsoft.ProjectOxford.Emotion.Contract.Scores).GetProperties() .Where(p => p.PropertyType == typeof(float)) .Select(p => new { Name = p.Name, Score = (float)p.GetValue(result[0].Scores) }); return emotionScores.OrderByDescending(s => s.Score).Select(s => s.Name).FirstOrDefault(); }
/// <summary> /// Pictures Libraryへファイルを保存する /// 既存の同名ファイルが存在している場合はファイルを上書きする /// </summary> /// <param name="fileName"></param> /// <param name="stream">エンコード済みの画像ストリーム</param> /// <returns></returns> public static async Task<StorageFile> SaveToPicturesLibraryAsync(string fileName, IRandomAccessStream stream) { var library = KnownFolders.PicturesLibrary; var file = await library.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); using (var writeStrm = await file.OpenStreamForWriteAsync()) { var readStrm = stream.AsStreamForRead(); readStrm.CopyTo(writeStrm); } return file; }
public async override Task<bool> SaveAsync(string cacheKey, IRandomAccessStream cacheStream) { var fullFileName = Path.Combine(CacheDirectory, CacheFileNameGenerator.GenerateCacheName(cacheKey)); var cacheSizeInBytes = cacheStream.AsStreamForRead().Length; while (CurrentCacheSizeInBytes + cacheSizeInBytes > _cacheLimitInBytes) { if (!await RemoveOldestCacheFile()) { break; // All cache deleted } } var wasFileSaved = await base.InternalSaveAsync(fullFileName, cacheStream); if (wasFileSaved) { _lastAccessTimeDictionary[Path.Combine(CacheDirectory, fullFileName)] = DateTimeHelper.CurrentTimeMillis(); CurrentCacheSizeInBytes += cacheSizeInBytes; // Updating current cache size } return wasFileSaved; }
public async Task<string> RecognizeTextAsync(IRandomAccessStream stream, string language = "unk", bool detectOrientation = true) { var response = await _client.RecognizeTextAsync(stream.AsStreamForRead(), language, detectOrientation); return response.Regions.SelectMany(r => r.Lines).SelectMany(l => l.Words).Select(w => w.Text).StringJoin(" "); }
private async Task<IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream) { XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead()); var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var writer = new Windows.Storage.Streams.DataWriter(outputStream); writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; var text = xmldoc.ToString(); var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\""); writer.WriteString(replacedText); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); return outputStream; }
public LoadResult Load(IRandomAccessStream lineStream) { StartLoad(lineStream.AsStreamForRead()); return CreateResult(); }