/// <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()); }
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 } } }
private async Task Listen() { Debug.WriteLine($"Sending connection acknowledgement"); await _socket.OutputStream.WriteAsync(Encoding.UTF8.GetBytes("0").AsBuffer()); while (true) { Debug.WriteLine($"Listening for socket command..."); IBuffer inbuffer = new Windows.Storage.Streams.Buffer(36); await _socket.InputStream.ReadAsync(inbuffer, 36, InputStreamOptions.Partial); string command = Encoding.UTF8.GetString(inbuffer.ToArray()); Debug.WriteLine($"Command received: {command}"); Guid guid = Guid.Empty; Guid.TryParse(command, out guid); byte[] data = _server.GetCurrentVideoDataAsync(guid); if (data != null) { await _socket.OutputStream.WriteAsync(data.AsBuffer()); } else { Debug.WriteLine($"Could not intialise, video does not exist"); } await Task.Delay(50); } }
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 <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()); }
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; }
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 } } }
/// <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); }
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); }
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); }
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 <byte[]> ReadAsync(int bufferSize, InputStreamOptions inputStreamOptions, CancellationToken cancellationToken) { var readBuffer = new Buffer((uint)bufferSize); await _serialDevice.InputStream.ReadAsync(readBuffer, readBuffer.Capacity, inputStreamOptions) .AsTask(cancellationToken); return(readBuffer.ToArray()); }
public async Task ReadAsync(byte[] buffer) { var buffer2 = new Buffer((uint)buffer.Length); await _socket.InputStream.ReadAsync(buffer2, (uint)buffer.Length, InputStreamOptions.None); var array2 = buffer2.ToArray(); Array.Copy(array2, buffer, array2.Length); }
void appendStringFromBufferBytes(uint start, uint count) { if (count > 0) { var bytes = buffer.ToArray(start, (int)count); var str = Encoding.UTF8.GetString(bytes, 0, bytes.Length); stringBuilder.Append(str); } }
public static async Task OnReceived(IInputStream dataStream, HostName remoteAddress) { IBuffer buffer = new Windows.Storage.Streams.Buffer(ReadBufferSize); await dataStream.ReadAsync(buffer, ReadBufferSize, InputStreamOptions.None); dataStream.Dispose(); var info = Encoding.UTF8.GetString(buffer.ToArray()); // TODO process unicast }
private async void SaveSoftwareBitmapToFile(SoftwareBitmap softwareBitmap) { using (var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) // (IRandomAccessStream stream = await outputFile.OpenAsync(FileAccessMode.ReadWrite)) { // Create an encoder with the desired format BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, memStream); // Set the software bitmap encoder.SetSoftwareBitmap(softwareBitmap); // Set additional encoding parameters, if needed encoder.BitmapTransform.ScaledWidth = 320; encoder.BitmapTransform.ScaledHeight = 240; //encoder.BitmapTransform.Rotation = Windows.Graphics.Imaging.BitmapRotation.Clockwise90Degrees; encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Fant; encoder.IsThumbnailGenerated = true; try { await encoder.FlushAsync(); // UploadImage // An array containing the decoded image data, which could be modified before being displayed IBuffer buff = new Windows.Storage.Streams.Buffer((uint)memStream.Size); memStream.Seek(0); IBuffer c = await memStream.ReadAsync(buff, buff.Capacity, InputStreamOptions.None); //WindowsRuntimeBufferExtensions.ToArray http://cctvapi.azurewebsites.net //await UploadImage("http://localhost:56407/Api/File/", buff.ToArray()) ; await UploadImage("http://cctvapi.azurewebsites.net/Api/File/", buff.ToArray()); } catch (Exception err) { switch (err.HResult) { case unchecked ((int)0x88982F81): //WINCODEC_ERR_UNSUPPORTEDOPERATION // If the encoder does not support writing a thumbnail, then try again // but disable thumbnail generation. encoder.IsThumbnailGenerated = false; break; default: throw err; } } if (encoder.IsThumbnailGenerated == false) { await encoder.FlushAsync(); } } }
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 static async Task <byte[]> GetByteRangeAsync(string path, long offset, int count) { var buffer = new Windows.Storage.Streams.Buffer((uint)count); var file = await StorageFile.GetFileFromPathAsync(path).AsTask().ConfigureAwait(false); using (var fs = await file.OpenAsync(FileAccessMode.Read).AsTask().ConfigureAwait(false)) { fs.Seek((ulong)offset); await fs.ReadAsync(buffer, (uint)count, InputStreamOptions.None).AsTask().ConfigureAwait(false); return(buffer.ToArray()); } }
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)); } }
public static async Task OnReceived(IInputStream dataStream, HostName remoteAddress) { IBuffer buffer = new Windows.Storage.Streams.Buffer(ReadBufferSize); await dataStream.ReadAsync(buffer, ReadBufferSize, InputStreamOptions.None); dataStream.Dispose(); var info = Encoding.UTF8.GetString(buffer.ToArray()); if (info.StartsWith(WindowsGoodbyeAuthTask.DeviceAlivePrefix) && info.Length > WindowsGoodbyeAuthTask.DeviceAlivePrefix.Length) { var payload = Convert.FromBase64String(info.Substring(WindowsGoodbyeAuthTask.DeviceAlivePrefix.Length)); if (payload.Length != 16) { return; } var guid = new Guid(payload); var session = WindowsGoodbyeAuthTask.deviceSessions.FirstOrDefault(s => s.DeviceInDb.DeviceId == guid); if (session != null) { session.Status = DeviceStatus.Established; } WindowsGoodbyeAuthTask.findAuth = false; } else if (info.StartsWith(WindowsGoodbyeAuthTask.AuthResponsePrefix) && info.Length > WindowsGoodbyeAuthTask.AuthResponsePrefix.Length) { var payload = Convert.FromBase64String(info.Substring(WindowsGoodbyeAuthTask.DeviceAlivePrefix.Length)); if (payload.Length <= 18) { return; } var guidBytes = new byte[16]; Array.Copy(payload, guidBytes, 16); var guid = new Guid(guidBytes); var session = WindowsGoodbyeAuthTask.deviceSessions.FirstOrDefault(s => s.DeviceInDb.DeviceId == guid); if (session == null) { return; } var resultBytes = new byte[payload.Length - 16]; Array.Copy(payload, 16, resultBytes, 0, resultBytes.Length); session.ResultBytes = resultBytes; WindowsGoodbyeAuthTask.AuthResultReceivedEvent.Set(); } }
public async Task <byte[]> GetLatestFrame() { var latestBitmap = Interlocked.Exchange(ref _backBuffer, null); using (var stream = new InMemoryRandomAccessStream()) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream); encoder.SetSoftwareBitmap(latestBitmap); await encoder.FlushAsync(); var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None); return(buffer.ToArray()); } }
public async Task <TransferResult> ReadAsync(uint bufferLength, CancellationToken cancellationToken = default) { IBuffer buffer; if (ReadEndpoint is UwpUsbInterfaceEndpoint <UsbBulkInPipe> usbBulkInPipe) { buffer = new wss.Buffer(bufferLength); _ = await usbBulkInPipe.Pipe.InputStream.ReadAsync(buffer, bufferLength, InputStreamOptions.None).AsTask(cancellationToken); //TODO: Seems there is no way to figure out how much data was read? return(new TransferResult(buffer.ToArray(), buffer.Length)); } else { return(InterruptReadEndpoint is UwpUsbInterfaceInterruptReadEndpoint usbInterruptInPipe ? await usbInterruptInPipe.ReadAsync(cancellationToken) : throw new DeviceException(Messages.ErrorMessageReadEndpointNotRecognized)); } }
public async Task Download(Uri url, StorageFile targetFile, CancellationToken token, Progress <HttpProgress> progress) { if (!url.IsAbsoluteUri) { url = new Uri(_serverUrl, url); } WebDavRequest request = new WebDavRequest(_credential, url, HttpMethod.Get); var response = await request.SendAsync(token, progress); if (response.IsSuccessStatusCode) { var inputStream = await response.Content.ReadAsInputStreamAsync(); IBuffer buffer = new Buffer(16 * 1024); using (var writingStream = await targetFile.OpenStreamForWriteAsync()) { ulong received = 0; do { buffer = await inputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.ReadAhead).AsTask(token); received += buffer.Length; await writingStream.WriteAsync(buffer.ToArray(), 0, (int)buffer.Length, token); ((IProgress <HttpProgress>)progress).Report(new HttpProgress { BytesReceived = received, TotalBytesToReceive = response.Content.Headers.ContentLength, Stage = HttpProgressStage.ReceivingContent }); if (token.IsCancellationRequested) { return; } } while (buffer.Length > 0); } } else { throw new WebDavException(response.StatusCode, response.ReasonPhrase, null); } }
public static async Task OnReceived(IInputStream dataStream, HostName remoteAddress) { IBuffer buffer = new Windows.Storage.Streams.Buffer(ReadBufferSize); await dataStream.ReadAsync(buffer, ReadBufferSize, InputStreamOptions.None); dataStream.Dispose(); var info = Encoding.UTF8.GetString(buffer.ToArray()); if (info.StartsWith(PairingRequestPrefix) && info.Length > PairingRequestPrefix.Length) { var payload = info.Substring(PairingRequestPrefix.Length); UdpEventPublisher.FirePairingRequestReceived(payload, IPAddress.Parse(remoteAddress.CanonicalName)); } else if (info.StartsWith(PairingTerminate)) { UdpEventPublisher.FirePairingTerminateReceived(IPAddress.Parse(remoteAddress.CanonicalName)); } }
private string ReadFromSocket() { Log.Default.Verbose("KnxClient: Waiting for response..."); var buffer = new Buffer(64); var readTask = _socket.InputStream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.Partial).AsTask(); readTask.ConfigureAwait(false); if (!readTask.Wait(Timeout)) { throw new TimeoutException("Timeout while reading KNX Client response."); } var response = Encoding.UTF8.GetString(buffer.ToArray()); Log.Default.Verbose($"KnxClient: Received {response}"); return(response); }
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 Listen() { //send an acknowledgement byte to the client app //to signal that we're ready to receive requests Debug.WriteLine($"Sending connection acknowledgement"); await _socket.OutputStream.WriteAsync(Encoding.UTF8.GetBytes("0").AsBuffer()); while (true) { //the client app is expected to request a new video, passing in a guid //as the "command", read 36 bytes from the buffer and try to parse it. Debug.WriteLine($"Listening for socket command..."); IBuffer inbuffer = new Windows.Storage.Streams.Buffer(36); await _socket.InputStream.ReadAsync(inbuffer, 36, InputStreamOptions.Partial); string command = Encoding.UTF8.GetString(inbuffer.ToArray()); Debug.WriteLine($"Command received: {command}"); //use the guid to either get the current video, or wait for the //next new one that's added by the server Guid guid = Guid.Empty; Guid.TryParse(command, out guid); byte[] data = _server.GetCurrentVideoDataAsync(guid); if (data != null) { await _socket.OutputStream.WriteAsync(data.AsBuffer()); } else { Debug.WriteLine($"Could not intialise, video does not exist"); } //add a brief delay to reduce system load await Task.Delay(50); } }
//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 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; } }
/// <summary> /// Called when [connection]. /// </summary> /// <param name="sender">The sender.</param> /// <param name="args">The <see cref="StreamSocketListenerConnectionReceivedEventArgs" /> instance containing the event data.</param> private async void OnConnection(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { StringBuilder request = new StringBuilder(); try { // Get the whole request. using (IInputStream inputStream = args.Socket.InputStream) { Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer(BufferLength); do { await inputStream.ReadAsync(buffer, BufferLength, InputStreamOptions.Partial); request.Append(Encoding.UTF8.GetString(buffer.ToArray(), 0, (int)buffer.Length)); } while (buffer.Length == BufferLength); } // Write the response. using (IOutputStream output = args.Socket.OutputStream) { await output.WriteAsync(this.CreateResponse()); } } catch (Exception exception) { // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { throw; } } }
/// <summary> /// Enters the read loop. /// </summary> internal void StartReadTask() { _readTaskQuit.Reset(); try { Task.Factory.StartNew(async() => { try { #if WINDOWS_UWP IBuffer lengthBuffer; #else var lengthBuffer = new byte[sizeof(uint)]; #endif while (true) { #if WINDOWS_UWP lengthBuffer = new Windows.Storage.Streams.Buffer(sizeof(uint)); while (lengthBuffer.Length < sizeof(uint)) { var progress = await _stream.ReadAsync(lengthBuffer, lengthBuffer.Capacity - lengthBuffer.Length, InputStreamOptions.Partial); if (progress == null) { Close(); return; } } /// ToDo: Check BitConverter.IsLittleEndian. var messageLength = BitConverter.ToUInt32(lengthBuffer.ToArray(), 0); if (messageLength <= 0) { continue; } var messageBuffer = new Windows.Storage.Streams.Buffer(messageLength); while (messageBuffer.Length < messageLength) { var progress = await _stream.ReadAsync(messageBuffer, messageBuffer.Capacity - messageBuffer.Length, InputStreamOptions.Partial); if (progress == null) { Close(); return; } } NetworkHost.Instance.QueueEvent(() => { var handler = MessageReceived; if (handler != null) { var message = new MessageStream(messageBuffer.ToArray()); handler(this, new TcpSocketReceiveEventArgs(this, message)); } }); #else var bufferPosition = 0; while (bufferPosition < sizeof(uint)) { var progress = await _stream.ReadAsync(lengthBuffer, bufferPosition, lengthBuffer.Length - bufferPosition, _quit.Token); if (progress == 0) { Close(); return; } bufferPosition += progress; } bufferPosition = 0; /// ToDo: Check BitConverter.IsLittleEndian. var messageLength = BitConverter.ToUInt32(lengthBuffer, 0); if (messageLength <= 0) { continue; } var messageBuffer = new byte[messageLength]; while (bufferPosition < messageLength) { var progress = await _stream.ReadAsync(messageBuffer, bufferPosition, messageBuffer.Length - bufferPosition, _quit.Token); if (progress == 0) { Close(); return; } bufferPosition += progress; } NetworkHost.Instance.QueueEvent(() => { var handler = MessageReceived; if (handler != null) { var message = new MessageStream(messageBuffer); handler(this, new TcpSocketReceiveEventArgs(this, message)); } }); #endif } } catch (ObjectDisposedException) { // The underlying Socket has been closed. Close(); } catch (Exception ex) { Debug.Write(ex); Close(); } finally { _readTaskQuit.Set(); } }, _quit.Token); } catch { _readTaskQuit.Set(); throw; } }
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 } } }
private static async Task<byte[]> GetByteRangeAsync(string path, int offset, int count) { var buffer = new Windows.Storage.Streams.Buffer((uint)count); var file = await StorageFile.GetFileFromPathAsync(path).AsTask().ConfigureAwait(false); using (var fs = await file.OpenAsync(FileAccessMode.Read).AsTask().ConfigureAwait(false)) { fs.Seek((ulong)offset); await fs.ReadAsync(buffer, (uint)count, InputStreamOptions.None).AsTask().ConfigureAwait(false); return buffer.ToArray(); } }
public static async Task <TLPhotoSizeBase> GetFileThumbAsync(StorageFile file) { try { const int imageSize = 60; IRandomAccessStream thumb = await file.GetThumbnailAsync(ThumbnailMode.SingleItem, imageSize, ThumbnailOptions.ResizeThumbnail); if (((StorageItemThumbnail)thumb).ContentType == "image/png") { var tempThumb = new InMemoryRandomAccessStream(); var decoder = await BitmapDecoder.CreateAsync(thumb); var pixels = await decoder.GetPixelDataAsync(); var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, tempThumb); encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore, decoder.PixelWidth, decoder.PixelHeight, decoder.DpiX, decoder.DpiY, pixels.DetachPixelData()); await encoder.FlushAsync(); thumb = tempThumb; } var volumeId = TLLong.Random(); var localId = TLInt.Random(); var secret = TLLong.Random(); var thumbLocation = new TLFileLocation { DCId = new TLInt(0), VolumeId = volumeId, LocalId = localId, Secret = secret, }; var fileName = String.Format("{0}_{1}_{2}.jpg", thumbLocation.VolumeId, thumbLocation.LocalId, thumbLocation.Secret); var thumbFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); var thumbBuffer = new Windows.Storage.Streams.Buffer(Convert.ToUInt32(thumb.Size)); var iBuf = await thumb.ReadAsync(thumbBuffer, thumbBuffer.Capacity, InputStreamOptions.None); using (var thumbStream = await thumbFile.OpenAsync(FileAccessMode.ReadWrite)) { await thumbStream.WriteAsync(iBuf); } var thumbSize = new TLPhotoSize { W = new TLInt(imageSize), H = new TLInt(imageSize), Size = new TLInt((int)thumb.Size), Type = TLString.Empty, Location = thumbLocation, Bytes = TLString.FromBigEndianData(thumbBuffer.ToArray()) }; return(thumbSize); } catch (Exception ex) { Telegram.Api.Helpers.Execute.ShowDebugMessage("GetFileThumbAsync exception " + ex); } return(null); }