public async void OnConnected(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { try { if (socket != null) { socket.Dispose(); //fecha o socket anterior } socket = args.Socket; Windows.Storage.Streams.Buffer bufferRx = new Windows.Storage.Streams.Buffer(600); string respostaOk = "OK"; IBuffer bufferTx = Encoding.ASCII.GetBytes(respostaOk).AsBuffer(); await socket.InputStream.ReadAsync(bufferRx, bufferRx.Capacity, InputStreamOptions.None); parametes = Encoding.ASCII.GetString(bufferRx.ToArray()).Replace("\0", ""); //this.textoPLC = System.Text.Encoding.ASCII.GetString(bufferRx.ToArray()); //Debug.WriteLine("Rx: " + ", from: " + socket.Information.RemoteAddress); await socket.OutputStream.WriteAsync(bufferTx); //Envia Ok como resposta } catch (Exception ex) { Debug.WriteLine("OnConnected Socket Exception " + ex.ToString()); } }
private async Task ConnectAsyncInternal(HostName hostName) { _tokenSource = new CancellationTokenSource(); _socket = new StreamSocket(); // połącz z kontrolerem na porcie 5555 await _socket.ConnectAsync(hostName, "5555", SocketProtectionLevel.PlainSocket); // wyslij komendę odblokowującą await _socket.OutputStream.WriteAsync(Encoding.UTF8.GetBytes(UnlockCommand).AsBuffer()); // read the "Accept:EV340\r\n\r\n" response //stworzenie bufor na odpowiedź IBuffer bufferResponse = new Buffer(128); //pobranie do bufora odpowiedzi przychodzącej od kontrolera EV3 await _socket.InputStream.ReadAsync(bufferResponse, bufferResponse.Capacity, InputStreamOptions.Partial); //przekształcenie danych z bufora na ciag znaków w formacie UTF8 string response = Encoding.UTF8.GetString(bufferResponse.ToArray(), 0, (int)bufferResponse.Length); if (string.IsNullOrEmpty(response)) //zgłoszenie błędu w razie braku odpowiedzi throw new Exception("LEGO EV3 brick did not respond to the unlock command."); //rozpoczęcie pobierania danych await ThreadPool.RunAsync(PollInput); }
public static async Task <byte[]> ComputeMD5(IRandomAccessStream stream) { var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5); var inputStream = stream.GetInputStreamAt(0); uint capacity = 1024 * 1024; var buffer = new Buffer(capacity); var hash = alg.CreateHash(); while (true) { await inputStream.ReadAsync(buffer, capacity, InputStreamOptions.None); if (buffer.Length > 0) { hash.Append(buffer); } else { break; } } return(hash.GetValueAndReset().ToArray()); //string hashText = CryptographicBuffer.EncodeToHexString(hash.GetValueAndReset()).ToUpper(); //var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5); ////IBuffer buff = //var hashed = alg.HashData(str.) //var res = CryptographicBuffer.EncodeToHexString(hashed); //return res; }
/// <summary> /// 获取Emoji的JSON /// </summary> /// <returns>JSON</returns> public async static Task <string> GetEmojis() { using (HttpClient client = new HttpClient()) { try { HttpResponseMessage response = await client.GetAsync(new Uri(EmojiLink)); if (null != response && response.StatusCode == HttpStatusCode.Ok) { using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream()) { await response.Content.WriteToStreamAsync(stream); stream.Seek(0); Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); await stream.ReadAsync(buffer, (uint)stream.Size, Windows.Storage.Streams.InputStreamOptions.Partial); using (DataReader reader = DataReader.FromBuffer(buffer)) { return(reader.ReadString((uint)stream.Size)); } } } }catch (Exception e) { Debug.WriteLine(e.Message); return(string.Empty); } return(string.Empty); } }
private IBuffer GetBuffer() { IBuffer buffer; var dequeued = _buffersQueue.TryDequeue(out buffer); if (!dequeued) buffer = new Buffer(SAMPLE_BUFFER_SIZE); return buffer; }
public static async Task<IBuffer> ReadIntoBuffer(IRandomAccessStream stream) { stream.Seek(0); var buffer = new Buffer((uint) stream.Size); await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); return buffer; }
internal static async Task <string> ReadStringFromFile(this string filename) { var text = string.Empty; try { var appFolder = Windows.ApplicationModel.Package.Current.InstalledLocation; Debug.WriteLine($"AppFolder {appFolder.Path}"); var storageFile = await appFolder.GetFileAsync(filename); var stream = await storageFile.OpenAsync(FileAccessMode.Read); var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None); if (buffer.Length > 0) { text = Encoding.UTF8.GetString(buffer.ToArray()); } } catch (Exception) { //await Display.Write($"Read failed {filename}"); } return(text); }
public async Task <IMediaModel> GenerateThumbImageFromVideo(DirectoryInfo argCurrentDataFolder, MediaModel argExistingMediaModel, IMediaModel argNewMediaModel) { StorageFolder currentFolder = await StorageFolder.GetFolderFromPathAsync(argCurrentDataFolder.FullName); StorageFile outfile = await currentFolder.CreateFileAsync(argNewMediaModel.OriginalFilePath, CreationCollisionOption.ReplaceExisting); //if (outfile.Name == "_e9e27fbe8ed34e9b554a0ba93aa~imagevideo.jpg") //{ //} StorageFile videoFile = await currentFolder.GetFileAsync(argExistingMediaModel.OriginalFilePath); StorageItemThumbnail thumbnail = await videoFile.GetThumbnailAsync(ThumbnailMode.SingleItem); Windows.Storage.Streams.Buffer MyBuffer = new Windows.Storage.Streams.Buffer(Convert.ToUInt32(thumbnail.Size)); IBuffer iBuf = await thumbnail.ReadAsync(MyBuffer, MyBuffer.Capacity, InputStreamOptions.None); IRandomAccessStream strm = await outfile.OpenAsync(FileAccessMode.ReadWrite); await strm.WriteAsync(iBuf); await strm.FlushAsync(); strm.Dispose(); // check size BasicProperties outProperties = await outfile.GetBasicPropertiesAsync(); if (outProperties.Size == 0) { return(new MediaModel()); } return(argNewMediaModel); }
// incoming data receive loop private async Task _receiveData() { try { var stream = _socket.InputStream; IBuffer buffer = new Windows.Storage.Streams.Buffer(10240); while (true) { IBuffer data = await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.Partial); if (data.Length == 0) { break; } _emitData(data); } // Client disconnected. _emitEnd(); _socket = null; if (_server != null) { _server._connectionDidClose(this); } } catch (System.IO.IOException ex) { NKLogging.log(ex.ToString()); } catch (Exception ex) { NKLogging.log(ex.ToString()); } }
/// <summary> /// Used for applying our video effect to a single frame. /// </summary> /// <param name="context"></param> public void ProcessFrame(ProcessVideoFrameContext context) { var inputFrameBitmap = context.InputFrame.SoftwareBitmap; // Create intermediate buffer for holding the frame pixel data. var frameSize = inputFrameBitmap.PixelWidth * inputFrameBitmap.PixelHeight * 4; var frameBuffer = new Buffer((uint)frameSize); // Copy bitmap data from the input frame. inputFrameBitmap.CopyToBuffer(frameBuffer); // Iterate through all pixels in the frame. var framePixels = frameBuffer.ToArray(); for (int i = 0; i < frameSize; i += 4) { // Calculate the luminance based on the RGB values - this way we can convert it to grayscale. var bValue = framePixels[i]; var gValue = framePixels[i + 1]; var rValue = framePixels[i + 2]; var luminance = ((rValue / 255.0f) * 0.2126f) + ((gValue / 255.0f) * 0.7152f) + ((bValue / 255.0f) * 0.0722f); // Set the pixel data to the calculated grayscale values. framePixels[i] = framePixels[i + 1] = framePixels[i + 2] = (byte)(luminance * 255.0f); } // Copy the modified frame data to the output frame. context.OutputFrame.SoftwareBitmap.CopyFromBuffer(framePixels.AsBuffer()); }
public static async Task<IBuffer> ToBuffer(this IRandomAccessStream stream) { stream.Seek(0); var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); return buffer; }
private async Task PollInputAsync() { while (!_tokenSource.IsCancellationRequested) { try { IBuffer sizeBuffer = new Buffer(2); await _socket.InputStream.ReadAsync(sizeBuffer, 2, InputStreamOptions.None); uint size = (uint)(sizeBuffer.GetByte(0) | sizeBuffer.GetByte(1) << 8); if (size != 0) { IBuffer data = new Buffer(size); await _socket.InputStream.ReadAsync(data, size, InputStreamOptions.None); RaiseDataReceived(data.ToArray()); } } catch (TaskCanceledException) { return; } catch (Exception) { // swallow exceptions...if we tank here, it's likely a disconnect and we can't do much anyway } } }
private async void PollInput(IAsyncAction operation) { while (!_tokenSource.IsCancellationRequested) { try { IBuffer sizeBuffer = new Buffer(2); await _socket.InputStream.ReadAsync(sizeBuffer, 2, InputStreamOptions.None); uint size = (uint)((sizeBuffer.GetByte(0) | sizeBuffer.GetByte(1) << 8)); if (size != 0) { IBuffer report = new Buffer(size); await _socket.InputStream.ReadAsync(report, size, InputStreamOptions.None); if (ReportReceived != null) { ReportReceived(this, new ReportReceivedEventArgs { Report = report.ToArray() }); } } } catch (Exception) { // swallow exceptions...if we tank here, it's likely a disconnect and we can't do much anyway } } }
public override int Read(byte[] buffer, int offset, int count) { Windows.Storage.Streams.Buffer tmpBuffer = new Windows.Storage.Streams.Buffer((uint)count); try { var task = Client.Socket.InputStream.ReadAsync(tmpBuffer, tmpBuffer.Capacity, InputStreamOptions.Partial) .AsTask(); task.ConfigureAwait(false); task.Wait(); } catch (AggregateException ex) { if (ex.InnerException != null) { throw ex.InnerException; } else { throw ex; } } DataReader reader = DataReader.FromBuffer(tmpBuffer); int length = (int)reader.UnconsumedBufferLength; for (int i = 0; i < length; ++i) { buffer[offset + i] = reader.ReadByte(); } return(length); }
/// <summary> /// Asynchronously saves all the album arts in the library. /// </summary> /// <param name="Data">ID3 tag of the song to get album art data from.</param> public async void SaveImages(Windows.Storage.FileProperties.StorageItemThumbnail thumb, Mediafile file) { var albumartFolder = ApplicationData.Current.LocalFolder; var md5Path = (file.Album + file.LeadArtist).ToLower().ToSha1(); if (!File.Exists(albumartFolder.Path + @"\AlbumArts\" + md5Path + ".jpg")) { IBuffer buf; Windows.Storage.Streams.Buffer inputBuffer = new Windows.Storage.Streams.Buffer(1024); var albumart = await albumartFolder.CreateFileAsync(@"AlbumArts\" + md5Path + ".jpg", CreationCollisionOption.FailIfExists); using (IRandomAccessStream albumstream = await albumart.OpenAsync(FileAccessMode.ReadWrite)) { while ((buf = (await thumb.ReadAsync(inputBuffer, inputBuffer.Capacity, Windows.Storage.Streams.InputStreamOptions.None))).Length > 0) { await albumstream.WriteAsync(buf); } //try //{ // var data = Data.AttachedPictureFrames["APIC"] as AttachedPictureFrame; // var stream = data.Data.AsRandomAccessStream(); // BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); // var x = await decoder.GetSoftwareBitmapAsync(); // BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, albumstream); // encoder.SetSoftwareBitmap(x); // await encoder.FlushAsync(); // stream.Dispose(); //} //catch(Exception ex) { Debug.Write(ex.Message + "||" + file.Path); } } thumb.Dispose(); } }
private async Task ConnectAsyncInternal(HostName hostName) { _tokenSource = new CancellationTokenSource(); _socket = new StreamSocket(); // connect to the brick on port 5555 await _socket.ConnectAsync(hostName, "5555", SocketProtectionLevel.PlainSocket); // unlock the brick (doesn't actually need serial number?) await _socket.OutputStream.WriteAsync(Encoding.UTF8.GetBytes(UnlockCommand).AsBuffer()); // read the "Accept:EV340\r\n\r\n" response IBuffer bufferResponse = new Buffer(128); await _socket.InputStream.ReadAsync(bufferResponse, bufferResponse.Capacity, InputStreamOptions.Partial); string response = Encoding.UTF8.GetString(bufferResponse.ToArray(), 0, (int)bufferResponse.Length); if (string.IsNullOrEmpty(response)) { throw new Exception("LEGO EV3 brick did not respond to the unlock command."); } await ThreadPool.RunAsync(PollInput); }
public static async Task <MHzSongBase> ReadSongModelFromStorageFileAsync(StorageFile storage) { using (var stream = await storage.OpenReadAsync()) { IBuffer buff = new Windows.Storage.Streams.Buffer((uint)stream.Size); var bytes = new byte[stream.Size]; await stream.AsStream().ReadAsync(bytes, 0, (int)stream.Size); var str = Encoding.UTF8.GetString(bytes); var result = default(MHzSongBase); try { result = JsonHelper.FromJson <MHzSongBase>(RepairForOldVersion(str)); result.LocalPath = storage.Path; } catch (SerializationException) { var music_file = await FetchStorageFileByPathAsync(storage.Path.Replace(JsonExtension, MusicExtension)); await storage.DeleteAsync(); await music_file.DeleteAsync(); return(null); } catch { return(null); } return(result); } }
public async Task <string> GetHashForFile(ListedItem fileItem, string nameOfAlg) { HashAlgorithmProvider algorithmProvider = HashAlgorithmProvider.OpenAlgorithm(nameOfAlg); var itemFromPath = await StorageFile.GetFileFromPathAsync(fileItem.ItemPath); var stream = await itemFromPath.OpenStreamForReadAsync(); var inputStream = stream.AsInputStream(); uint capacity = 100000000; Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(capacity); var hash = algorithmProvider.CreateHash(); while (true) { await inputStream.ReadAsync(buffer, capacity, InputStreamOptions.None); if (buffer.Length > 0) { hash.Append(buffer); } else { break; } } inputStream.Dispose(); stream.Dispose(); return(CryptographicBuffer.EncodeToHexString(hash.GetValueAndReset()).ToLower()); }
/// <summary> /// Asynchronously saves all the album arts in the library. /// </summary> /// <param name="Data">ID3 tag of the song to get album art data from.</param> public static async Task <bool> SaveImagesAsync(Windows.Storage.FileProperties.StorageItemThumbnail thumb, Mediafile file) { var albumartFolder = ApplicationData.Current.LocalFolder; var md5Path = (file.Album + file.LeadArtist).ToLower().ToSha1(); if (!File.Exists(albumartFolder.Path + @"\AlbumArts\" + md5Path + ".jpg")) { try { Windows.Storage.Streams.IBuffer buf; Windows.Storage.Streams.Buffer inputBuffer = new Windows.Storage.Streams.Buffer(1024); var albumart = await albumartFolder.CreateFileAsync(@"AlbumArts\" + md5Path + ".jpg", CreationCollisionOption.FailIfExists).AsTask().ConfigureAwait(false); using (Windows.Storage.Streams.IRandomAccessStream albumstream = await albumart.OpenAsync(FileAccessMode.ReadWrite).AsTask().ConfigureAwait(false)) { while ((buf = (await thumb.ReadAsync(inputBuffer, inputBuffer.Capacity, Windows.Storage.Streams.InputStreamOptions.None).AsTask().ConfigureAwait(false))).Length > 0) { await albumstream.WriteAsync(buf).AsTask().ConfigureAwait(false); } } thumb.Dispose(); return(true); } catch (Exception ex) { await NotificationManager.ShowAsync(ex.Message + "||" + file.Path); return(false); } } return(false); }
public void When_Create_Then_LengthIsZero() { var sut = new Buffer(42); Assert.AreEqual(0U, sut.Length); Assert.AreEqual(42U, sut.Capacity); }
private async Task <byte[]> ReadAsync(int bufferLength) { var buffer = new Windows.Storage.Streams.Buffer((uint)bufferLength); await NetworkStream.InputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); return(buffer.ToArray()); }
public async void Save() { var fileSavePicker = new FileSavePicker { SuggestedStartLocation = PickerLocationId.PicturesLibrary, SuggestedFileName = "Sketch", }; fileSavePicker.FileTypeChoices.Add("PNG file", new List <string> { ".png" }); var file = await fileSavePicker.PickSaveFileAsync(); if (file != null) { var png = await GeneratePng(); CachedFileManager.DeferUpdates(file); var buffer = new Buffer((uint)png.Size); await png.ReadAsync(buffer, (uint)png.Size, InputStreamOptions.None); await FileIO.WriteBufferAsync(file, buffer); var status = await CachedFileManager.CompleteUpdatesAsync(file); if (status != FileUpdateStatus.Complete) { // failed } } }
private async void AppBar_LoadDefault_Button_Click(object sender, RoutedEventArgs e) { string currentDirectory = Directory.GetCurrentDirectory(); //$"C:\\Users\\steve\\Documents"; // // Load the XML file from our project directory containing the purchase orders string potentialdata_filename = "SeawaterPotentialData.xml"; string galvPotentialFilepath = Path.Combine(currentDirectory, potentialdata_filename); StorageFile temp_file = await StorageFile.GetFileFromPathAsync(galvPotentialFilepath); string alloytreatment_filename = "AlloyTreatmentRecommendations.xml"; string treatmentFilepath = Path.Combine(currentDirectory, alloytreatment_filename); StorageFile temp_file_2 = await StorageFile.GetFileFromPathAsync(treatmentFilepath); if (temp_file != null) { sampleFile = temp_file; } if (sampleFile != null) { try { using (IRandomAccessStream readstream = await sampleFile.OpenAsync(FileAccessMode.Read)) { ulong size64 = readstream.Size; if (size64 <= uint.MaxValue) { uint size32 = (uint)size64; IBuffer buffer = new Windows.Storage.Streams.Buffer(size32); buffer = await readstream.ReadAsync(buffer, size32, InputStreamOptions.None); string filecontent = GetStringFromBuffer(buffer); XElement xmlroot = XElement.Parse(filecontent); IEnumerable <XElement> MaterialNames = from el in xmlroot.Elements("Data") select el; foreach (XElement el in MaterialNames) { ListOfAnodes.Items.Add(el.Element("Name").Value); ListOfCathodes.Items.Add(el.Element("Name").Value); } ListOfAnodes.IsEnabled = true; } else { await displayMessageAsync("Alert message", "Your data file is too large. It needs to be < 4 GB.", "notification"); } } } catch { await displayMessageAsync("Fail message", "The default data file did not load correctly.", "notification"); } } if (temp_file_2 != null) { treatmentFile = temp_file_2; } }
/// <summary> /// Non-blocking read implementation /// </summary> /// <param name="socket"></param> /// <param name="size"></param> /// <returns></returns> public byte[] ReadNonBlocking(Connection conn, uint size) { try { StreamSocket socket = conn.sock; IBuffer buffer = new Windows.Storage.Streams.Buffer(size); var t = Task <byte[]> .Run(async() => { buffer = await socket.InputStream.ReadAsync(buffer, size, InputStreamOptions.Partial); if (buffer.Length == 0) { return(null); } else { return(buffer.ToArray()); } }); t.Wait(); return(t.Result); } catch (Exception e) { OneWireEventSource.Log.Debug("ReadNonBlocking(): " + e.ToString()); } return(null); }
public async void StartVideoRecordingOnThread(StreamSocket _socket) { //Make sure the MediaCapture object is initialized await CheckSetUp(); Streamer streamer = new Streamer(_socket); // When the streamer is connected, create a new Output stream using the streamer isRecording = true; while (true) { InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream(); await _mediaCapture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Vga), stream); await Task.Delay(TimeSpan.FromSeconds(1)); await _mediaCapture.StopRecordAsync(); stream.Seek(0); Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); await stream.ReadAsync(buffer, (uint)stream.Size, Windows.Storage.Streams.InputStreamOptions.None); streamer.WriteToSocketUsingReader(buffer); } }
private void ListenForMessage() { IBuffer buffer = new Windows.Storage.Streams.Buffer((uint)currentReceivedMessage.Length); IAsyncOperationWithProgress <IBuffer, uint> newmessagereceived = networkConnection.InputStream.ReadAsync(buffer, (uint)currentReceivedMessage.Length, new InputStreamOptions()); newmessagereceived.Completed = new AsyncOperationWithProgressCompletedHandler <IBuffer, uint>(MessageReceived); }
private void ListenForMessageHeader() { IBuffer buffer = new Windows.Storage.Streams.Buffer(sizeof(ulong)); IAsyncOperationWithProgress <IBuffer, uint> newmessagereceived = networkConnection.InputStream.ReadAsync(buffer, sizeof(ulong), new InputStreamOptions()); newmessagereceived.Completed = new AsyncOperationWithProgressCompletedHandler <IBuffer, uint>(MessageHeaderReceived); }
/// <summary> /// 用于上传拖拽的文件,每次可上传多个文件 /// </summary> /// <param name="cts"></param> /// <param name="files"></param> /// <param name="beforeUpload"></param> /// <param name="afterUpload"></param> /// <returns></returns> public static async Task <List <string>[]> UploadFileAsync(CancellationTokenSource cts, IReadOnlyList <IStorageItem> files, Action <int, int, string> beforeUpload, Action <int> afterUpload) { var fileNameList = new List <string>(); // 用于与其他文本内容一起POST var fileCodeList = new List <string>(); // 用于插入内容文本框 if (files != null && files.Count > 0) { int fileIndex = 1; foreach (var file in files) { string fileName = file.Name; beforeUpload?.Invoke(fileIndex, files.Count, fileName); fileNameList.Add(fileName); //byte[] imageBuffer; //if (deviceFamily.Equals("Windows.Mobile")) //{ // imageBuffer = await ImageHelper.LoadAsync(file); //} //else //{ IRandomAccessStream stream = await((StorageFile)file).OpenAsync(FileAccessMode.Read); IBuffer buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); buffer = await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); //} var data = new Dictionary <string, object>(); data.Add("uid", AccountService.UserId); data.Add("hash", AccountService.Hash); try { string url = "http://www.hi-pda.com/forum/misc.php?action=swfupload&operation=upload&simple=1"; string result = await _httpClient.PostFileAsync(url, data, fileName, "Filedata", buffer, cts); if (result.Contains("DISCUZUPLOAD|")) { string value = result.Split('|')[2]; value = $"[attachimg]{value}[/attachimg]"; fileCodeList.Add(value); fileIndex++; } } catch (Exception ex) { Debug.WriteLine(ex.Message); } } afterUpload?.Invoke(files.Count); } return(new List <string>[] { fileNameList, fileCodeList }); }
public async Task <int> Receive(byte[] buffer, Action <int> callback, Action <Exception> error, int offset) { try { var ibuffer = new Windows.Storage.Streams.Buffer((uint)buffer.Length); DataReader reader = new DataReader(_socket.InputStream); reader.InputStreamOptions = InputStreamOptions.Partial; uint count = await reader.LoadAsync((uint)buffer.Length); byte[] bytes = new byte[count]; reader.ReadBytes(bytes); reader.DetachStream(); bytes.CopyTo(buffer, 0); //var result = await _socket.InputStream.AsStreamForRead(buffer.Length).ReadAsync(buffer, offset, buffer.Length,_tokenSource.Token); //var result = await _socket.InputStream.ReadAsync(ibuffer, (uint)buffer.Length, Windows.Storage.Streams.InputStreamOptions.None); callback((int)count); return((int)count); } catch (Exception e) { error(e); return(0); } }
public WriteableBitmap(int pixelWidth, int pixelHeight) : base() { _buffer = new UwpBuffer((uint)(pixelWidth * pixelHeight * 4)); PixelWidth = pixelWidth; PixelHeight = pixelHeight; }
public override int Read(byte[] buffer, int offset, int count) { Windows.Storage.Streams.Buffer tmpBuffer = new Windows.Storage.Streams.Buffer((uint)count); try { var task = Client.Socket.InputStream.ReadAsync(tmpBuffer, (uint)count, InputStreamOptions.None); task.AsTask().Wait(); } catch(AggregateException ex) { if (ex.InnerException != null) throw ex.InnerException; else throw ex; } /*byte[] tmpBuff = tmpBuffer.ToArray(); int length = Math.Min(tmpBuff.Length, count); Array.Copy(tmpBuff, 0, buffer, offset, length); return length;*/ DataReader buf = DataReader.FromBuffer(tmpBuffer); int length = (int)buf.UnconsumedBufferLength; for (int i = 0; i < length; ++i) buffer[offset + i] = buf.ReadByte(); return length; }
private void ReadMore() { IBuffer buffer = new Windows.Storage.Streams.Buffer(1024); readOperation = inputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.Partial); readOperation.Completed = OnReadCompleted; }
public async Task DownloadFile(string path, StorageFile destFile) { Uri uri = GetUri($"/api/files/{Utils.EncodePath(path)}/download"); if (uri == null) { return; } using (IRandomAccessStream fileStream = await destFile.OpenAsync(FileAccessMode.ReadWrite)) { using (HttpClient client = GetClient()) { using (IInputStream downloadStream = await client.GetInputStreamAsync(uri)) { const uint capacity = 1_000_000; Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(capacity); while (true) { await downloadStream.ReadAsync(buffer, capacity, InputStreamOptions.None); if (buffer.Length == 0) { break; } await fileStream.WriteAsync(buffer); } } } } }
async private void AppBarButton_Click_4(object sender, RoutedEventArgs e) { //Uri uri = new Uri("http://www.charlespetzold.com/pw6/PetzoldJersey.jpg"); Uri uri = new Uri("ms-appx:///PetzoldJersey.jpg"); RandomAccessStreamReference streamRef = RandomAccessStreamReference.CreateFromUri(uri); // Create a buffer for reading the stream Windows.Storage.Streams.Buffer buffer = null; // Read the entire file using (IRandomAccessStreamWithContentType fileStream = await streamRef.OpenReadAsync()) { buffer = new Windows.Storage.Streams.Buffer((uint)fileStream.Size); await fileStream.ReadAsync(buffer, (uint)fileStream.Size, InputStreamOptions.None); } // Create WriteableBitmap with unknown size WriteableBitmap bitmap = new WriteableBitmap(1, 1); // Create a memory stream for transferring the data using (InMemoryRandomAccessStream memoryStream = new InMemoryRandomAccessStream()) { await memoryStream.WriteAsync(buffer); memoryStream.Seek(0); // Use the memory stream as the Bitmap source bitmap.SetSource(memoryStream); } // Now get the pixels from the bitmap byte[] pixels = new byte[4 * bitmap.PixelWidth * bitmap.PixelHeight]; int index = 0; using (Stream pixelStream = bitmap.PixelBuffer.AsStream()) { await pixelStream.ReadAsync(pixels, 0, pixels.Length); // Apply opacity to the pixels for (int y = 0; y < bitmap.PixelHeight; y++) { double opacity = (double)y / bitmap.PixelHeight; for (int x = 0; x < bitmap.PixelWidth; x++) { for (int i = 0; i < 4; i++) { pixels[index] = (byte)(opacity * pixels[index]); index++; } } } // Put the pixels back in the bitmap pixelStream.Seek(0, SeekOrigin.Begin); await pixelStream.WriteAsync(pixels, 0, pixels.Length); } bitmap.Invalidate(); reflectedImage.Source = bitmap; }
internal static async Task<string> ReadStringFromFile(this string filename) { var text = string.Empty; try { var appFolder = Windows.ApplicationModel.Package.Current.InstalledLocation; Debug.WriteLine($"AppFolder {appFolder.Path}"); var storageFile = await appFolder.GetFileAsync(filename); var stream = await storageFile.OpenAsync(FileAccessMode.Read); var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None); if (buffer.Length > 0) text = Encoding.UTF8.GetString(buffer.ToArray()); } catch (Exception) { //await Display.Write($"Read failed {filename}"); } return text; }
public static Func <HttpRequest, HttpResponse, Task> Create(StorageFolder dataFolder) { return(async(request, response) => { string filePath = request.ReqLine.Uri == "/" ? DefaultFile : request.ReqLine.Uri; filePath = filePath.Replace('/', '\\'); var file = await dataFolder.GetFileAsync(filePath); await response.WriteHeadersAsync( HttpStatus.OK, Tuple.Create(HttpHeader.ContentType, file.ContentType), Tuple.Create(HttpHeader.ContentLength, (await file.GetBasicPropertiesAsync()).Size.ToString()) ); var stream = ((StreamWriterAsync)response.Stream).Stream; var buffer = new Windows.Storage.Streams.Buffer(DefaultBufferSize); using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite)) { do { await fs.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.ReadAhead); await stream.WriteAsync(buffer); } while (buffer.Length == buffer.Capacity); } }); }
private async Task ReadAsync(StreamSocket socket) { IBuffer readBuffer = new Windows.Storage.Streams.Buffer(1024); while (true) { IBuffer buffer; try { buffer = await socket.InputStream.ReadAsync(readBuffer, 1024, InputStreamOptions.Partial); } catch { await Stop().ConfigureAwait(true); return; } if (buffer.Length != 0) { var data = new byte[buffer.Length]; using (DataReader dataReader = DataReader.FromBuffer(buffer)) { dataReader.ReadBytes(data); outputText.AppendBinary(data, data.Length); } } else { status.Text = "Disconnected."; await Stop().ConfigureAwait(true); return; } } }
private async void buttonReceive_Click(object sender, RoutedEventArgs e) { var buffer = new Windows.Storage.Streams.Buffer(1024); var readBytes = await App.Socket.InputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.Partial); GetString(GetByteArrayFromBuffer(buffer)); //txtMsg.Text += GetString(GetByteArrayFromBuffer(buffer)); }
protected override async void Loop() { Streams.DataReader reader = null; try { while (true) { if (socket == null) { socket = new StreamSocket(); await socket.ConnectAsync(new HostName(DroneClient.Host), _ServiceName); } var readBuf = new Streams.Buffer((uint)NetworkBufferSize); var readOp = socket.InputStream.ReadAsync(readBuf, (uint)NetworkBufferSize, Streams.InputStreamOptions.Partial); readOp.Completed = (IAsyncOperationWithProgress<Streams.IBuffer, uint> asyncAction, AsyncStatus asyncStatus) => { switch (asyncStatus) { case AsyncStatus.Completed: Debug.WriteLine("Config:Completed "); try { Streams.IBuffer localBuf = asyncAction.GetResults(); uint bytesRead = localBuf.Length; Debug.WriteLine("Config:Buffer (" + bytesRead + ")"); reader = Streams.DataReader.FromBuffer(localBuf); OnDataReadCompletion(bytesRead, reader); } catch (Exception e) { Debug.WriteLine(e.ToString()); } break; case AsyncStatus.Canceled: Debug.WriteLine("Config:Canceled "); break; case AsyncStatus.Error: Debug.WriteLine("Config:Error "); break; } }; //socket.Dispose(); await Task.Delay(500); } } catch (Exception e) { Debug.WriteLine(e.ToString()); Stop(); } }
public async Task WaitForFrameAsync() { var buffer = new Buffer(RequestBufferSize); await _clientSocket.InputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.Partial); var data = new List<byte>(_overhead); _overhead = new byte[0]; data.AddRange(buffer.ToArray()); var parseWebSocketFrameResult = WebSocketFrame.Parse(data.ToArray()); if (parseWebSocketFrameResult.WebSocketFrame == null) { _overhead = parseWebSocketFrameResult.Overhead; return; } var webSocketFrame = parseWebSocketFrameResult.WebSocketFrame; switch (webSocketFrame.Opcode) { case WebSocketOpcode.Ping: { webSocketFrame.Opcode = WebSocketOpcode.Pong; await SendAsync(webSocketFrame); return; } case WebSocketOpcode.ConnectionClose: { CloseAsync().Wait(); return; } case WebSocketOpcode.Pong: { return; } } _frameQueue.Add(webSocketFrame); if (webSocketFrame.Fin) { var message = GenerateMessage(); _frameQueue.Clear(); MessageReceived?.Invoke(this, new WebSocketMessageReceivedEventArgs(message, this)); } }
private async Task<int> ReceiveAsync(byte[] outbuffer) { IBuffer buffer = new Windows.Storage.Streams.Buffer((uint)outbuffer.Length); buffer = await socket.InputStream.ReadAsync(buffer, buffer.Capacity, Windows.Storage.Streams.InputStreamOptions.None); if (buffer.Length < outbuffer.Length) { var outbuffer2 = new byte[buffer.Length]; DataReader.FromBuffer(buffer).ReadBytes(outbuffer2); Array.Copy(outbuffer2, outbuffer, Math.Min(outbuffer.Length, outbuffer2.Length)); } else { DataReader.FromBuffer(buffer).ReadBytes(outbuffer); } return (int)buffer.Length; }
public async Task<ReturnElements> GetScreen() { ReturnElements retelement = new ReturnElements(); // Get the bitmap and display it. var dataPackageView = Windows.ApplicationModel.DataTransfer.Clipboard.GetContent(); if (dataPackageView.Contains(StandardDataFormats.Bitmap)) { IRandomAccessStreamReference imageReceived = null; try { imageReceived = await dataPackageView.GetBitmapAsync(); if (imageReceived != null) { using (IRandomAccessStream imageStream = await imageReceived.OpenReadAsync()) { StorageFolder folder = await ApplicationData.Current.LocalFolder.GetFolderAsync("Temp"); if (folder == null) folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Temp", CreationCollisionOption.ReplaceExisting); StorageFile file = await folder.CreateFileAsync("MyPainter.png", CreationCollisionOption.ReplaceExisting); Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer((uint)imageStream.Size); await imageStream.ReadAsync(buffer, (uint)imageStream.Size, InputStreamOptions.None); await FileIO.WriteBufferAsync(file, buffer); control.factory.IsGetScreenSucccess = true; retelement.success = true; return retelement; } } } catch (Exception ex) { control.factory.IsGetScreenSucccess = false; retelement.success = false; return retelement; } } control.factory.IsGetScreenSucccess = false; retelement.success = false; return retelement; }
public static async Task<string> ComputeMd5(IInputStream stream, BinaryStringEncoding encoding = BinaryStringEncoding.Utf8) { var hashAlgorithmProvider = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5); var hash = hashAlgorithmProvider.CreateHash(); uint size = 1024*64; var buffer = new Buffer(size); while (true) { var x = await stream.ReadAsync(buffer, size, InputStreamOptions.Partial); if (x.Length < 1) { break; } hash.Append(x); } var result = hash.GetValueAndReset(); var hex = CryptographicBuffer.EncodeToHexString(result); return hex; }
private async Task ConnectAsyncInternal(HostName hostName) { _tokenSource = new CancellationTokenSource(); _socket = new StreamSocket(); // connect to the brick on port 5555 await _socket.ConnectAsync(hostName, "5555", SocketProtectionLevel.PlainSocket); // unlock the brick (doesn't actually need serial number?) await _socket.OutputStream.WriteAsync(Encoding.UTF8.GetBytes(UnlockCommand).AsBuffer()); // read the "Accept:EV340\r\n\r\n" response IBuffer bufferResponse = new Buffer(128); await _socket.InputStream.ReadAsync(bufferResponse, bufferResponse.Capacity, InputStreamOptions.Partial); string response = Encoding.UTF8.GetString(bufferResponse.ToArray(), 0, (int)bufferResponse.Length); if (string.IsNullOrEmpty(response)) throw new Exception("LEGO EV3 brick did not respond to the unlock command."); await ThreadPool.RunAsync(PollInput); }
private async Task SendHearbeat() { using (var socket = new StreamSocket()) { await socket.ConnectAsync(new HostName(_server.ToString()), _port.ToString()); var formatter = new HeartBeatListener.Formatter(); var writer = new DataWriter(socket.OutputStream); IBuffer buffer = null; if (State == CameraClientState.Idle) { buffer = await StorageIO.ReadIntoBuffer(await _camera.Snapshot()); } else { buffer = new StreamBuffer(0); } Debug.WriteLine($"Hearbeat state {State}"); await formatter.Write(writer, new CameraHeartBeat(_listener.LocalHost.ToString(), buffer, State)); await writer.StoreAsync(); } }
/// <summary> /// There are no custom descriptors for the SuperMutt and OSRFX2 devices, however, this method will show you how to /// navigate through raw descriptors. The raw descriptors can be found in UsbConfiguration and /// UsbInterface, and UsbInterfaceSetting. All possible descriptors that you would find in the full Configuration Descriptor /// are found under UsbConfiguration. /// All raw descriptors under UsbInterface are constrained only to those that are found under the InterfaceDescriptor /// that is defined in the Usb spec. /// /// Usb descriptor header (first 2 bytes): /// bLength Size of descriptor in bytes /// bDescriptorType The type of descriptor (configuration, interface, endpoint) /// </summary> private String GetCustomDescriptorsAsString() { String content = null; if (EventHandlerForDevice.Current.IsDeviceConnected) { // Descriptor information will be appended to this string and then printed to UI content = "Raw Descriptors"; var configuration = EventHandlerForDevice.Current.Device.Configuration; var allRawDescriptors = configuration.Descriptors; // Print first 2 bytes of all descriptors within the configuration descriptor // because the first 2 bytes are always length and descriptor type // the UsbDescriptor's DescriptorType and Length properties, but we will not use these properties // in order to demonstrate ReadDescriptorBuffer() and how to parse it. foreach (UsbDescriptor descriptor in allRawDescriptors) { var descriptorBuffer = new Windows.Storage.Streams.Buffer(descriptor.Length); descriptor.ReadDescriptorBuffer(descriptorBuffer); DataReader reader = DataReader.FromBuffer(descriptorBuffer); // USB data is Little Endian according to the USB spec. reader.ByteOrder = ByteOrder.LittleEndian; // ReadByte has a side effect where it consumes the current byte, so the next ReadByte will read the next character. // Putting multiple ReadByte() on the same line (same variable assignment) may cause the bytes to be read out of order. var length = reader.ReadByte().ToString("D", NumberFormatInfo.InvariantInfo); var type = "0x" + reader.ReadByte().ToString("X2", NumberFormatInfo.InvariantInfo); content += "\n\nDescriptor" + "\nLength : " + length + "\nDescriptorType : " + type; } } return content; }
/// <summary> /// this is used when the user selects save to file /// </summary> /// <remarks> /// to implement this, we will need to create and instance of the save file picker /// then write the output stream into a file /// </remarks> /// <param name="sender"></param> /// <param name="e"></param> private async void BtnSaveToFile_Click(object sender, RoutedEventArgs e) { string text = this.tbData.Text; // select the file to save this data to FileSavePicker savePicker = new FileSavePicker(); savePicker.DefaultFileExtension = ".wav"; // this is the only type available savePicker.FileTypeChoices.Add("Audio file", new List<string>() { ".wav" }); StorageFile file = await savePicker.PickSaveFileAsync(); if (file != null) { this.btnSaveToFile.IsEnabled = false; // create the data stream SpeechSynthesisStream synthesisStream; try { synthesisStream = await this.synthesizer.SynthesizeSsmlToStreamAsync(text); } catch (Exception) { synthesisStream = null; this.btnSaveToFile.IsEnabled = true; } if (synthesisStream == null) { MessageDialog dialog = new MessageDialog("unable to synthesize text"); await dialog.ShowAsync(); return; } // open the output stream Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(4096); IRandomAccessStream writeStream = (IRandomAccessStream)await file.OpenAsync(FileAccessMode.ReadWrite); IOutputStream outputStream = writeStream.GetOutputStreamAt(0); DataWriter dataWriter = new DataWriter(outputStream); // copy the stream data into the file while (synthesisStream.Position < synthesisStream.Size) { await synthesisStream.ReadAsync(buffer, 4096, InputStreamOptions.None); dataWriter.WriteBuffer(buffer); } // close the data file streams dataWriter.StoreAsync().AsTask().Wait(); outputStream.FlushAsync().AsTask().Wait(); this.btnSaveToFile.IsEnabled = true; } }
public async void StartListening() { while (true) { try { hostName = new HostName("localhost"); } catch (ArgumentException) { continue; } //CoreApplication.Properties.Add("clientSocket", socket); try { socket = new StreamSocket(); await socket.ConnectAsync(hostName, port1); //CoreApplication.Properties.Add("connected", null); } catch { continue; } try { Windows.Storage.Streams.Buffer b = new Windows.Storage.Streams.Buffer(6000); var xxx = await socket.InputStream.ReadAsync(b, b.Capacity, InputStreamOptions.None); DataReader dr = DataReader.FromBuffer(b); string str = dr.ReadString(dr.UnconsumedBufferLength); if (this.TorrentInfoReceived != null) { TorrentInfo ti = Commons.Serializer.Deserialize<TorrentInfo>(str); TorrentInfoReceived(ti); } } catch { //break; } } }
private async Task<VideoDataStructure> saveNonLocalFileToLocalAndAddVideoToList(StorageFile storageFile) { VideoDataStructure pds = null; try { IRandomAccessStream iras = await storageFile.OpenReadAsync(); Windows.Storage.Streams.Buffer MyBuffer = new Windows.Storage.Streams.Buffer(Convert.ToUInt32(iras.Size)); IBuffer iBuf = await iras.ReadAsync(MyBuffer, MyBuffer.Capacity, InputStreamOptions.None); string filename = DateTime.Now.ToString().Replace(":", "").Replace("/", "_").Replace("\\", "_").Replace(".", "").Replace("\"", "") + "lifemapcover" + storageFile.Name; string filePath = await Helper.SaveImages(iBuf, filename); StorageFile file = await Windows.Storage.StorageFile.GetFileFromPathAsync(filePath); StorageItemThumbnail fileThumbnail = await file.GetThumbnailAsync(ThumbnailMode.SingleItem, 600); BitmapImage bitmapImage = new BitmapImage(); bitmapImage.SetSource(fileThumbnail); pds = new VideoDataStructure() { VideoData = new DataModel.VideoDataStructure() { AlbumId = albumInfo.Id, Latitude = albumInfo.Latitude, Longitude = albumInfo.Longitude, VideoPath = filePath, ItemId = DateTime.Now.ToString() + file.Path }, Image = bitmapImage, VideoWidthHeight = Constants.HalfScreenHeight - 35, VideoWidth = (Constants.HalfScreenHeight - 35) * (Convert.ToDouble(bitmapImage.PixelWidth) / Convert.ToDouble(bitmapImage.PixelHeight)) }; } catch (Exception exp) { //Constants.ShowWarningDialog(Constants.ResourceLoader.GetString("2FileLocalizationFailed") + "\n\r" + exp.Message); } return pds; }
//Tache async qui ecoute en permanance le serveur private async void ReadSocketAsync(StreamSocket _socket) { while (true) { const uint size = 2048; IBuffer buffer = new Windows.Storage.Streams.Buffer(size); buffer = await _socket.InputStream.ReadAsync(buffer, size, InputStreamOptions.Partial); var handler = DataReceived; if (handler != null && buffer.Length > 0) { byte[] Array = buffer.ToArray(); string reponse = Encoding.UTF8.GetString(Array, 0, Array.Length); if (reponse != "<EOF>") { string[] separator = new string[] { "<EOF>" }; string[] phrases = reponse.Split(separator, StringSplitOptions.None); foreach (string phrase in phrases) { if (phrase != "") { Newtonsoft.Json.Linq.JObject jsonNoData = (Newtonsoft.Json.Linq.JObject)JsonConvert.DeserializeObject(phrase); if (jsonNoData["action"].ToString() == "talk") { reponse = jsonNoData["message"].ToString(); } else if (jsonNoData["action"].ToString() == "execute") { reponse = "Je ne peux pas faire cela..."; } else if (jsonNoData["action"].ToString() == "sound") { reponse = "Je ne peux pas faire cela..."; } handler(this, new DataReceivedEventArgs(reponse)); if (tts) parle(reponse); } } } if (allmessages.Count() != 0) { myChat.UpdateLayout(); myChat.ScrollIntoView(allmessages.Last()); } } } }
private static async Task fillBackgroundImageNonLocal(LifeMapStructure lifeMap, StorageFile storageFile) { try { IRandomAccessStream iras = await storageFile.OpenReadAsync(); Windows.Storage.Streams.Buffer MyBuffer = new Windows.Storage.Streams.Buffer(Convert.ToUInt32(iras.Size)); IBuffer iBuf = await iras.ReadAsync(MyBuffer, MyBuffer.Capacity, InputStreamOptions.None); string filename = DateTime.Now.ToString().Replace(":", "").Replace("/", "_").Replace("\\", "_").Replace(".", "").Replace("\"", "") + "lifemapcover" + storageFile.Name; string filePath = await Helper.SaveImages(iBuf, filename); lifeMap.ImagePath = filePath; await Utils.FilesSaver<LifeMapStructure>.SaveData(Data.LifeMapMgr.LifeMaps, Constants.NamingListLifeMaps); StorageFile file = await Windows.Storage.StorageFile.GetFileFromPathAsync(lifeMap.ImagePath); StorageItemThumbnail fileThumbnail = await file.GetThumbnailAsync(ThumbnailMode.SingleItem, 800); BitmapImage bitmapImage = new BitmapImage(); bitmapImage.SetSource(fileThumbnail); lifeMap.Image = bitmapImage; Helper.CreateToastNotifications(Constants.ResourceLoader.GetString("UpdatedLiftMapBackground")); } catch(Exception exp) { lifeMap.ImagePath = ""; Utils.Constants.ShowWarningDialog(Constants.ResourceLoader.GetString("2cannotreadfile") + " : " + exp.Message + "\n\r" + Constants.ResourceLoader.GetString("2possiblereasoncannotaccessnonlocalfile")); } }
/// <summary> /// Caches the given object to the Application's ImageCache /// and returns the uri of the cached file. /// </summary> /// <param name="objectToCache">Object to cache</param> /// <param name="cacheFileName">Name of the cache file</param> /// <param name="progressHandler">Delegate for handling progress</param> /// <returns>Uri</returns> public async Task<Uri> GetCachedUriAsync(object objectToCache, string cacheFileName, CacheProgressHandler progressHandler = null) { // Check if the objectToCache is a valid Uri var uri = objectToCache as Uri; if (uri == null) { // Is the objectToCache a string representing a Uri? var uriString = objectToCache as string; if (uriString != null) { // Try creating the Uri from the uriString if (!(Uri.TryCreate(uriString, UriKind.RelativeOrAbsolute, out uri))) { return null; } } } // Calculate the expiry date var expirationDate = DateTime.Now.Subtract(ImageCache.CacheDuration); // Get the cache folder location var cacheFolder = await ImageCache.GetCacheFolderAsync(); if (cacheFolder == null) return null; // Report Progress progressHandler?.Invoke(0); // Get the cache file corresponding to the cacheFileName var cacheFile = await cacheFolder.TryGetItemAsync(cacheFileName) as StorageFile; // Has the cache file expired or does it not exist? if (await cacheFile.IsNullOrExpired(expirationDate)) { try { // Create/Recreate the cache file cacheFile = await cacheFolder.CreateFileAsync(cacheFileName, CreationCollisionOption.ReplaceExisting); using (var httpClient = new HttpClient()) { // Use HttpCompletionOption.ResponseHeadersRead for the GetAsync call so that it returns as // soon as response headers are received and not when the whole response is received using (var response = await httpClient.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead)) { // If respose status is not success then raise exception response.EnsureSuccessStatusCode(); // Open the cache file for writing using (var cacheStream = await cacheFile.OpenAsync(FileAccessMode.ReadWrite)) { // Start reading the content as a stream using (var inputStream = await response.Content.ReadAsInputStreamAsync()) { ulong totalBytesRead = 0; var prevProgress = -1; var totalContentLength = response.Content.Headers.ContentLength ?? 0UL; while (true) { // Read from the stream IBuffer buffer = new Windows.Storage.Streams.Buffer(2048); buffer = await inputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); if (buffer.Length == 0) { // There is nothing else to read break; } // The following code can be used to report progress totalBytesRead += buffer.Length; if (totalContentLength > 0UL) { // We will report a progress percent between 0%-80% because caching represents 80% // of the task of displaying the image. The other 20% requires successful loading // of the cached image. var progress = (int)Math.Round((totalBytesRead * 80) / (double)totalContentLength); if (progress != prevProgress) { // Report Progress progressHandler?.Invoke(progress); prevProgress = progress; } } else { prevProgress = Math.Min(prevProgress + 1, 80); // Report Progress progressHandler?.Invoke(prevProgress); } // Write to cache file await cacheStream.WriteAsync(buffer); } } } } } } catch (Exception) { // In case any exception occurs during the downloading or caching // delete the cacheFile and return a 'null' Uri cacheFile = await cacheFolder.TryGetItemAsync(cacheFileName) as StorageFile; if (cacheFile != null) { await cacheFile.DeleteAsync(); } // Report Progress progressHandler?.Invoke(-1); return null; } } // Report Progress // Caching indicates only half of the task completed i.e. 50% progress, // Progress will be 100% only when the image is loaded successfully on the ImageFrame progressHandler?.Invoke(80); // Now that we have a valid cached file for the Uri, return the Uri of the cached inputFile return new Uri($"ms-appdata:///temp/{ImageCache.CacheFolderName}/{cacheFileName}"); }
private async void PollInput(IAsyncAction operation) { while (!_tokenSource.IsCancellationRequested) { try { IBuffer sizeBuffer = new Buffer(2); await _socket.InputStream.ReadAsync(sizeBuffer, 2, InputStreamOptions.None); uint size = (uint)((sizeBuffer.GetByte(0) | sizeBuffer.GetByte(1) << 8)); if (size != 0) { IBuffer report = new Buffer(size); await _socket.InputStream.ReadAsync(report, size, InputStreamOptions.None); if (ReportReceived != null) ReportReceived(this, new ReportReceivedEventArgs { Report = report.ToArray() }); } } catch (Exception) { // swallow exceptions...if we tank here, it's likely a disconnect and we can't do much anyway } } }
public async void Run(IBackgroundTaskInstance taskInstance) { using (new BackgroundTaskDeferralWrapper(taskInstance.GetDeferral())) { try { var details = (SocketActivityTriggerDetails)taskInstance.TriggerDetails; switch (details.Reason) { case SocketActivityTriggerReason.SocketActivity: string request = null; using (var socketOperation = Hub.Instance.SignalingSocketService.SocketOperation) { if (socketOperation.Socket != null) { var socket = socketOperation.Socket; const uint length = 65536; var readBuf = new Buffer(length); var readOp = socket.InputStream.ReadAsync(readBuf, length, InputStreamOptions.Partial); // This delay is to limit how long we wait for reading. // StreamSocket has no ability to peek to see if there's any // data waiting to be read. So we have to limit it this way. for (int i = 0; i < 100 && readOp.Status == Windows.Foundation.AsyncStatus.Started; ++i) { await Task.Delay(10); } await socket.CancelIOAsync(); try { var localBuffer = await readOp; var dataReader = DataReader.FromBuffer(localBuffer); request = dataReader.ReadString(dataReader.UnconsumedBufferLength); } catch (Exception ex) { Debug.WriteLine($"ReadAsync exception probably due to timeout: {ex.Message}"); } } } if (request != null) { Hub.Instance.SignalingClient.HandleRequest(request); } break; case SocketActivityTriggerReason.KeepAliveTimerExpired: Hub.Instance.SignalingClient.ClientHeartBeat(); break; case SocketActivityTriggerReason.SocketClosed: Hub.Instance.SignalingClient.ServerConnectionError(); //ToastNotificationService.ShowToastNotification("Disconnected."); break; } } catch (Exception exception) { Hub.Instance.SignalingClient.ServerConnectionError(); ToastNotificationService.ShowToastNotification(string.Format("Error in SignalingTask: {0}", exception.Message)); } } }
/// <summary> /// Await loading an image from an external web site /// </summary> /// <param name="uri"></param> public async Task<WriteableBitmap> LoadImageWriteableBitmapFromWeb(Uri uri) { // From Petzold, Programming Windows, 6th edition pg. 692-3 /* This simple method will return before the file read is complete. As expected, this is a problem: RandomAccessStreamReference streamRef = RandomAccessStreamReference.CreateFromUri(uri); IRandomAccessStreamWithContentType fileStream = await streamRef.OpenReadAsync(); WriteableBitmap wb = new WriteableBitmap(1, 1); // dummy values wb.SetSource(fileStream); return wb; */ try { RandomAccessStreamReference streamRef = RandomAccessStreamReference.CreateFromUri(uri); // Create a buffer for reading the stream: Windows.Storage.Streams.Buffer buffer = null; // Read the entire file: using (IRandomAccessStreamWithContentType fileStream = await streamRef.OpenReadAsync()) { buffer = new Windows.Storage.Streams.Buffer((uint)fileStream.Size); await fileStream.ReadAsync(buffer, (uint)fileStream.Size, InputStreamOptions.None); } WriteableBitmap wb = new WriteableBitmap(1, 1); // dummy values // Create a memory stream for transferring the data using (InMemoryRandomAccessStream memoryStream = new InMemoryRandomAccessStream()) { await memoryStream.WriteAsync(buffer); memoryStream.Seek(0); // Use the memory stream as the Bitmap Source wb.SetSource(memoryStream); } return wb; } catch(Exception) { return null; // new Dec 2014. Probably bad, dangling uri. Let caller report & handle error. } }
private async Task<HttpRequest> ReadRequest(StreamSocket client) { try { IBuffer buffer = new Buffer(2048); await client.InputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.Partial); var binaryRequest = buffer.ToArray(); var requestText = Encoding.ASCII.GetString(binaryRequest, 0, binaryRequest.Length); HttpRequest request; new HttpRequestParser(requestText).TryParse(out request); return request; } catch (Exception exception) { Debug.WriteLine("Failed to read HTTP request. " + exception.Message); return null; } }
private async Task<string> CreateSpeechSynthesisFile(TTSMessage item) { string filename = String.Format("{0}.wav", Guid.NewGuid()); try { // get system voice that matches the gender var voice = (from v in voices where v.Gender == (Windows.Media.SpeechSynthesis.VoiceGender)item.VoiceGender.VoiceGenderId select v).FirstOrDefault<VoiceInformation>(); synthesizer.Voice = voice; // create the data stream SpeechSynthesisStream synthesisStream; try { synthesisStream = await synthesizer.SynthesizeTextToStreamAsync(item.Message); } catch (Exception ex) { ri.SendException("Unable to synthesize text", ex); synthesisStream = null; return string.Empty; } ri.SendMessage("Creating file '{0}'", filename); StorageFolder folder = await StorageFolder.GetFolderFromPathAsync("C:\\temp\\TTS"); //Windows.Storage.KnownFolders.DocumentsLibrary;// Windows.Storage.ApplicationData.Current.LocalFolder; var option = CreationCollisionOption.ReplaceExisting; StorageFile file = await folder.CreateFileAsync(filename, option); ri.SendMessage("File '{0}' created. Text to speech synthesis has started...", file.Path); // open the output stream Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(4096); IRandomAccessStream writeStream = (IRandomAccessStream)await file.OpenAsync(FileAccessMode.ReadWrite); IOutputStream outputStream = writeStream.GetOutputStreamAt(0); DataWriter dataWriter = new DataWriter(outputStream); // copy the stream data into the file while (synthesisStream.Position < synthesisStream.Size) { await synthesisStream.ReadAsync(buffer, 4096, InputStreamOptions.None); dataWriter.WriteBuffer(buffer); } // close the data file streams dataWriter.StoreAsync().AsTask().Wait(); outputStream.FlushAsync().AsTask().Wait(); ri.SendMessage("Text to speech synthesis completed for file '{0}'", file.Name); } catch (Exception e) { ri.SendException(e); return String.Empty; } return filename; }
private async void _socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { var stream = args.GetDataStream(); IBuffer buffer = new Windows.Storage.Streams.Buffer(10240); var bytesRead = buffer.Capacity; while (bytesRead == buffer.Capacity) { IBuffer data = await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.Partial); bytesRead = data.Length; if (data.Length == 0) break; _emitRecv(data, args.RemoteAddress.DisplayName, Int32.Parse(args.RemotePort)); } }
/// <summary> /// Caches the given object to the Application's ImageCache /// and returns the uri of the cached file. /// </summary> /// <param name="objectToCache">Object to cache</param> /// <param name="cacheFileName">Name of the cache file</param> /// <param name="progressHandler">Delegate for handling progress</param> /// <returns>Uri</returns> public async Task<Uri> GetCachedUriAsync(object objectToCache, string cacheFileName, CacheProgressHandler progressHandler = null) { // Check if the objectToCache is a valid IRandomAccessStream var stream = objectToCache as IRandomAccessStream; if ((stream == null) || !stream.CanRead) return null; // Calculate the expiry date var expirationDate = DateTime.Now.Subtract(ImageCache.CacheDuration); // Get the cache folder location var cacheFolder = await ImageCache.GetCacheFolderAsync(); if (cacheFolder == null) return null; // Report Progress progressHandler?.Invoke(0); // Get the cache file corresponding to the cacheFileName var cacheFile = await cacheFolder.TryGetItemAsync(cacheFileName) as StorageFile; // Has the cache file expired or does it not exist? if (await cacheFile.IsNullOrExpired(expirationDate)) { try { // Create/Recreate the cache file cacheFile = await cacheFolder.CreateFileAsync(cacheFileName, CreationCollisionOption.ReplaceExisting); // Open the cache file for writing using (var cacheStream = await cacheFile.OpenAsync(FileAccessMode.ReadWrite)) { // Start reading the content as a stream using (var inputStream = stream.GetInputStreamAt(0)) { ulong totalBytesRead = 0; var prevProgress = -1; var totalContentLength = stream.Size; if (totalContentLength <= 0UL) { prevProgress = 0; } while (true) { // Read from the stream IBuffer buffer = new Windows.Storage.Streams.Buffer(2048); buffer = await inputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); if (buffer.Length == 0) { // There is nothing else to read break; } // The following code can be used to report progress totalBytesRead += buffer.Length; if (totalContentLength > 0UL) { // We will report a progress percent between 0%-80% because caching represents 80% // of the task of displaying the image. The other 20% requires successful loading // of the cached image. var progress = (int)Math.Round((totalBytesRead * 80) / (double)totalContentLength); if (progress != prevProgress) { // Report Progress progressHandler?.Invoke(progress); prevProgress = progress; } } else { prevProgress = Math.Min(prevProgress + 1, 80); // Report Progress progressHandler?.Invoke(prevProgress); } // Write to cache file await cacheStream.WriteAsync(buffer); } } } } catch (Exception) { // In case any exception occurs during the copying of the StorageFile // delete the cacheFile and return a 'null' Uri cacheFile = await cacheFolder.TryGetItemAsync(cacheFileName) as StorageFile; if (cacheFile != null) { await cacheFile.DeleteAsync(); } // Report Progress progressHandler?.Invoke(-1); return null; } } // Report Progress // Caching indicates only half of the task completed i.e. 50% progress, // Progress will be 100% only when the image is loaded successfully on the ImageFrame progressHandler?.Invoke(80); // Now that we have a valid cached file for the Uri, return the Uri of the cached inputFile return new Uri($"ms-appdata:///temp/{ImageCache.CacheFolderName}/{cacheFileName}"); }
//private StreamSocket _socket; private async void button_Click(object sender, RoutedEventArgs e) { OutBuff = new Windows.Storage.Streams.Buffer(100); Button button = (Button)sender; if (button != null) { switch ((string)button.Content) { case "Disconnect": await this._socket.CancelIOAsync(); _socket.Dispose(); _socket = null; this.textBlockBTName.Text = ""; this.TxtBlock_SelectedID.Text = ""; this.buttonDisconnect.IsEnabled = false; this.buttonSend.IsEnabled = false; this.buttonStartRecv.IsEnabled = false; this.buttonStopRecv.IsEnabled = false; break; case "Send": //await _socket.OutputStream.WriteAsync(OutBuff); Send(this.textBoxSendText.Text); this.textBoxSendText.Text = ""; break; case "Clear Send": this.recvdText.Text = ""; break; case "Start Recv": this.buttonStartRecv.IsEnabled = false; this.buttonStopRecv.IsEnabled = true; Listen(); break; case "Stop Recv": this.buttonStartRecv.IsEnabled = false; this.buttonStopRecv.IsEnabled = false; CancelReadTask(); break; case "Refresh": InitializeRfcommDeviceService(); break; case "Back": //this.Frame.GoBack(); backButton_Click(null, null); break; } } }