/// <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);
}
