private async Task<string> DoCommand(string command) { StringBuilder strBuilder = new StringBuilder(); using (StreamSocket clientSocket = new StreamSocket()) { await clientSocket.ConnectAsync(new HostName("192.168.9.108"), "9001"); using (DataWriter writer = new DataWriter(clientSocket.OutputStream)) { writer.WriteString(command); await writer.StoreAsync(); writer.DetachStream(); } using (DataReader reader = new DataReader(clientSocket.InputStream)) { reader.InputStreamOptions = InputStreamOptions.Partial; await reader.LoadAsync(8192); while (reader.UnconsumedBufferLength > 0) { strBuilder.Append(reader.ReadString(reader.UnconsumedBufferLength)); await reader.LoadAsync(8192); } reader.DetachStream(); } } return (strBuilder.ToString()); }
private async Task<RfidReaderResult> Read() { RfidReaderResult retvalue = new RfidReaderResult(); var dataReader = new DataReader(_rfidReader.InputStream); try { SetStatus("Awaiting Data from RFID Reader"); var numBytesRecvd = await dataReader.LoadAsync(1024); retvalue.Result = new byte[numBytesRecvd]; if (numBytesRecvd > 0) { SetStatus("Data successfully read from RFID Reader"); dataReader.ReadBytes(retvalue.Result); retvalue.IsSuccessful = true; retvalue.Message = "Data successfully read from RFID Reader"; } } catch (Exception ex) { retvalue.IsSuccessful = false; retvalue.Message = ex.Message; } finally { if (dataReader != null) { dataReader.DetachStream(); dataReader = null; } } return retvalue; }
private async void read_data() { ifListening = true; // int read_msg_counter = 2; using (var reader = new Windows.Storage.Streams.DataReader(streamSocket.InputStream)){ reader.InputStreamOptions = Windows.Storage.Streams.InputStreamOptions.ReadAhead; reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; reader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; await reader.LoadAsync(4); while (reader.UnconsumedBufferLength > 0) { // read_msg_counter--; int bytesToRerad = reader.ReadInt32(); // Debug.Log("bytes to read: " + bytesToRerad); if (bytesToRerad <= 0) { return; } await reader.LoadAsync(Convert.ToUInt32(bytesToRerad)); byte[] buffer = new byte[bytesToRerad]; reader.ReadBytes(buffer); processReceivedData(buffer, bytesToRerad); await reader.LoadAsync(4); } reader.DetachStream(); } ifListening = false; }
public async Task <string> ReadLogFile(string fileName) { if (fileName != this.FQP) { int index = fileName.IndexOf(DIRECTORY_NAME); fileName = fileName.Substring(index); var file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); if (file == null) { return(""); } return(await Windows.Storage.FileIO.ReadTextAsync(file)); } if (_logFile != null) { using (var inputStream = _stream.GetInputStreamAt(0)) { Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(inputStream); await reader.LoadAsync((uint)_stream.Size); string data = reader.ReadString((uint)_stream.Size); reader.DetachStream(); return(data); } } return(""); }
/// <summary> /// Read string content from file. /// </summary> /// <param name="path">Location of file, separate by //.</param> /// <param name="rootFolder"> </param> /// <returns>Content of file.</returns> public async Task<string> ReadFromFileAsync(string path, StorageFolder rootFolder = null) { if (path == null) { return null; } try { var file = await GetFileToReadAsync(path, rootFolder); if (file == null) { return null; } var readStream = await file.OpenAsync(FileAccessMode.Read); var inputStream = readStream.GetInputStreamAt(0); var dataReader = new DataReader(inputStream); var numBytesLoaded = await dataReader.LoadAsync((uint)readStream.Size); var content = dataReader.ReadString(numBytesLoaded); dataReader.DetachStream(); dataReader.Dispose(); inputStream.Dispose(); readStream.Dispose(); return content; } catch { return null; } }
public static async Task<string> ReadLine(this IInputStream inputStream) { using (var dataReader = new DataReader(inputStream)) { var line = await dataReader.ReadLine(); dataReader.DetachStream(); return line; } }
public async Task <T> LoadASync(string FileName) { FileName = FileName + ".xml"; try { StorageFile file = null; StorageFolder folder = GetFolder(storageType); file = await folder.GetFileAsync(FileName); //using (var readStream = await file.OpenAsync(FileAccessMode.Read)) //{ // Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(readStream); // await reader.LoadAsync((uint)readStream.Size); // string data = reader.ReadString((uint)readStream.Size); // if (data == null) // { // } //} using (var readStream = await file.OpenAsync(FileAccessMode.Read)) { //Stream inStream = Task.Run(() => readStream.AsStreamForRead()).Result; //return (T)serializer.Deserialize(inStream); var inStream = readStream.GetInputStreamAt(0); Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(inStream); await reader.LoadAsync((uint)readStream.Size); string data = reader.ReadString((uint)readStream.Size); reader.DetachStream(); MemoryStream ms = new MemoryStream(UTF8Encoding.UTF8.GetBytes(data)); DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T)); T result = (T)ser.ReadObject(ms); return(result); } } catch (FileNotFoundException) { //file not existing is perfectly valid so simply return the default return(default(T)); //throw; } catch (Exception) { //Unable to load contents of file throw; } }
internal static async Task<string> ReadTextAsync(this StorageFile file) { using (var fs = await file.OpenAsync(FileAccessMode.Read)) { using (var inStream = fs.GetInputStreamAt(0)) { using (var dataReader = new DataReader(inStream)) { await dataReader.LoadAsync((uint)fs.Size); var data = dataReader.ReadString((uint)fs.Size); dataReader.DetachStream(); return data; } } } }
/// <summary> /// Копировать из RT потока в .NET поток с прогрессом. /// </summary> /// <param name="src">Исхоный поток.</param> /// <param name="outStream">Поток результата.</param> /// <param name="progress">Прогресс.</param> /// <param name="token">Токен отмены.</param> /// <param name="bufferSize">Размер буфера.</param> /// <returns>Таск.</returns> public static async Task CopyToNetStreamWithProgress(this IInputStream src, Stream outStream, IProgress<ulong> progress, CancellationToken token, uint bufferSize = 16384) { ulong totalRead = 0; using (var rd = new DataReader(src)) { progress.Report(0); do { token.ThrowIfCancellationRequested(); var r = await rd.LoadAsync(bufferSize); totalRead += r; progress.Report(totalRead); if (r <= 0) break; var buf = new byte[r]; rd.ReadBytes(buf); await outStream.WriteAsync(buf, 0, (int)r, token); } while (true); rd.DetachStream(); } }
public async void StartReader(ConnectedPeer connectedPeer) { try { using (var socketReader = new Windows.Storage.Streams.DataReader(connectedPeer._socket.InputStream)) { // Read the message sent by the remote peer uint bytesRead = await socketReader.LoadAsync(sizeof(uint)); if (bytesRead > 0) { uint strLength = (uint)socketReader.ReadUInt32(); bytesRead = await socketReader.LoadAsync(strLength); if (bytesRead > 0) { String message = socketReader.ReadString(strLength); OnRaiseMessageEvent(new MessageEventArgs("Got message: " + message)); StartReader(connectedPeer); // Start another reader } else { OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket")); } } else { OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket")); } socketReader.DetachStream(); } } catch (Exception e) { if (!connectedPeer._socketClosed) { OnRaiseSocketErrorEvent(new SocketEventArgs("Reading from socket failed: " + e.Message)); } } }
public static async Task<string> ReadFromFile( string fileName, StorageFolder folder = null) { folder = folder ?? ApplicationData.Current.LocalFolder; var file = await folder.GetFileAsync(fileName); using (var fs = await file.OpenAsync(FileAccessMode.Read)) { using (var inStream = fs.GetInputStreamAt(0)) { using (var reader = new DataReader(inStream)) { await reader.LoadAsync((uint)fs.Size); string data = reader.ReadString((uint)fs.Size); reader.DetachStream(); return data; } } } }
public static async Task<DateTimeOffset?> RetrieveLinkerTimestamp(Assembly assembly) { var pkg = Windows.ApplicationModel.Package.Current; if (null == pkg) { return null; } var assemblyFile = await pkg.InstalledLocation.GetFileAsync(assembly.ManifestModule.Name); if (null == assemblyFile) { return null; } using (var stream = await assemblyFile.OpenSequentialReadAsync()) { using (var reader = new DataReader(stream)) { const int PeHeaderOffset = 60; const int LinkerTimestampOffset = 8; //read first 2048 bytes from the assembly file. byte[] b = new byte[2048]; await reader.LoadAsync((uint)b.Length); reader.ReadBytes(b); reader.DetachStream(); //get the pe header offset int i = System.BitConverter.ToInt32(b, PeHeaderOffset); //read the linker timestamp from the PE header int secondsSince1970 = System.BitConverter.ToInt32(b, i + LinkerTimestampOffset); var dt = new DateTimeOffset(1970, 1, 1, 0, 0, 0, DateTimeOffset.Now.Offset) + DateTimeOffset.Now.Offset; return dt.AddSeconds(secondsSince1970); } } }
private async void ValidateAndLoadSketch() { if (!_isJavascriptReady || !_isBrowserLoaded) return; var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///sketch.pde", UriKind.RelativeOrAbsolute)); using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var inStream = fs.GetInputStreamAt(0)) { using (var dataReader = new DataReader(inStream)) { await dataReader.LoadAsync((uint)fs.Size); _sketchText = dataReader.ReadString((uint)fs.Size); dataReader.DetachStream(); } } } if (_sketchText != "") Browser.InvokeScript("loadSketch", new[] { _sketchText }); }
// // TCP server and TCP client common. // private async Task<string> ReadUntilCrLf(IInputStream inputStream, TextBlock outputTextBlock) { DataReader reader = new DataReader(inputStream); reader.InputStreamOptions = InputStreamOptions.Partial; string message = ""; while (!message.EndsWith("\r\n")) { // Read bytes in multiples of 16, to make it more fun. // If the socket is closed while we are reading, the "The I/O operation has // been aborted because of either a thread exit or an application request. // (Exception from HRESULT: 0x800703E3)" exception is thrown. uint bytesRead = await reader.LoadAsync(16); if (bytesRead == 0) { // If bytesRead is zero, incoming stream was closed. DisplayOutput(outputTextBlock, "The connection was closed by remote host."); break; } // TODO: Why DataReader doesn't have ReadChar()? message += reader.ReadString(bytesRead); } // Do not use Dispose(). If used, streams cannot be used anymore. //reader.Dispose(); // Without this, the DataReader destructor will close the stream, and closing the // stream might set the FIN control bit. reader.DetachStream(); return message; }
public static async Task<string> Recive(StreamSocket streamSocket, List<string> orstarts, List<string> orends, List<string> andstarts, List<string> andends) { string returnString = string.Empty; try { using (var dataReader = new DataReader(streamSocket.InputStream)) { dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dataReader.InputStreamOptions = InputStreamOptions.Partial; var end = false; while (!end && await dataReader.LoadAsync(64000) != 0) { string readString; var buffer = dataReader.ReadBuffer(dataReader.UnconsumedBufferLength); using (var dr = DataReader.FromBuffer(buffer)) { var bytes1251 = new Byte[buffer.Length]; dr.ReadBytes(bytes1251); readString = Encoding.GetEncoding("UTF-8").GetString(bytes1251, 0, bytes1251.Length); } if (!string.IsNullOrEmpty(readString)) returnString += readString; if (readString == null) { end = true; } else if (orstarts.FirstOrDefault(o => returnString.StartsWith(o)) != null) { end = true; } else if (orends.FirstOrDefault(o => returnString.EndsWith(o)) != null) { end = true; } else if (andstarts.FirstOrDefault(o => returnString.StartsWith(o)) != null && andends.FirstOrDefault(o => returnString.EndsWith(o)) != null) { end = true; } } dataReader.DetachStream(); } } catch(Exception ex) { Debug.WriteLine(ex.Message); returnString = string.Empty; } return returnString; }
public IAsyncOperation<string> Connect() { var window = CoreWindow.GetForCurrentThread(); return Task.Run<string>(async () => { try { var socket = this.socket = new Windows.Networking.Sockets.StreamSocket(); await socket.ConnectAsync(new HostName("talk.google.com"), "5222", SocketProtectionLevel.PlainSocket); await log(window, "connected!"); reader = new DataReader(socket.InputStream); writer = new DataWriter(socket.OutputStream); reader.InputStreamOptions = InputStreamOptions.Partial; Write("<?xml version='1.0'?>\n<stream:stream to='" + server + "' xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'>"); xmlStream = new XmlStream(); bool shouldRead = true; xmlStream.SetCallback(async (promptRead, data) => { await log(window, "data " + data); if (promptRead) { if (shouldRead) { await log(window, "prompt read"); await reader.LoadAsync(4096); var buffer = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(buffer); await log(window, "in " + Encoding.UTF8.GetString(buffer, 0, buffer.Length)); xmlStream.Update(buffer, 0, buffer.Length); } else { await log(window, "read blocked"); } } else if (data.IndexOf("stream:features") != -1) { Write("<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls' />"); } else if (data.IndexOf("proceed") != -1) { await log(window, "SSL Strength: " + socket.Information.ProtectionLevel); writer.DetachStream(); reader.DetachStream(); shouldRead = false; if (server == "gmail.com") { await socket.UpgradeToSslAsync(SocketProtectionLevel.Ssl, new Windows.Networking.HostName("gmail.com")); } else { await socket.UpgradeToSslAsync(SocketProtectionLevel.Ssl, new Windows.Networking.HostName("talk.google.com")); } writer = new DataWriter(socket.OutputStream); reader = new DataReader(socket.InputStream); reader.InputStreamOptions = InputStreamOptions.Partial; await log(window, "upgraded!"); await log(window, "SSL Strength: " + socket.Information.ProtectionLevel); Write("<?xml version='1.0'?>\n<stream:stream to='" + server + "' xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'>"); xmlStream.SetCallback(async (shouldRead2, data2) => { await log(window, "data " + data2); if (shouldRead2) { await reader.LoadAsync(4096); var buffer = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(buffer); await log(window, "in " + Encoding.UTF8.GetString(buffer, 0, buffer.Length)); xmlStream.Update(buffer, 0, buffer.Length); } else if (data2.Contains("X-GOOGLE-TOKEN")) { var token = Convert.ToBase64String(Encoding.UTF8.GetBytes('\x00' + this.username + '\x00' + this.auth)); Write("<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='X-GOOGLE-TOKEN'>" + token + "</auth>"); } else if (data2.Contains("failure")) { if (Disconnect != null) Disconnect(this, "auth failure"); } else if (data2.Contains("success")) { var messageEvent = Message; xmlStream.SetCallback(async (shouldRead3, data3) => { if (shouldRead3) { await reader.LoadAsync(4096); var buffer = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(buffer); await log(window, "in " + Encoding.UTF8.GetString(buffer, 0, buffer.Length)); xmlStream.Update(buffer, 0, buffer.Length); } else if (data3 == "</stream:stream>") { await disconnect(window, "end of stream"); } else if (!data3.StartsWith("<stream:stream")) { await message(window, data3); } }); Write("<?xml version='1.0'?>\n<stream:stream to='" + server + "' xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'>"); } else if (!data2.StartsWith("<stream:stream")) { await log(window, "Ummm not sure what to do with '" + data2 + "'. flee."); if (Disconnect != null) Disconnect(this, "protocol error"); } }); } else if (!data.StartsWith("<stream:stream")) { await log(window, "Ummm not sure what to do with '" + data + "'. flee."); if (Disconnect != null) Disconnect(this, "protocol error"); } }); return "ok"; } catch (Exception e) { return e.ToString(); } }).AsAsyncOperation<string>(); }
async private void recieveData() { StreamSocketListener listener = new StreamSocketListener(); DataReader dr = new DataReader(newSocket.InputStream); dr.InputStreamOptions = InputStreamOptions.Partial; string msg = null; try { var count = await dr.LoadAsync(8192); if (count > 0) msg = dr.ReadString(count); } catch { } dr.DetachStream(); dr.Dispose(); try { pdu2 = new PDU(msg); Execution temp = pdu2.Data.ToObject(typeof(Execution)); _stepCollection.Clear(); foreach (Step steps in temp.CurrentSequence.StepList) { _stepCollection.Add(steps); } } catch (Exception e) { } Execution temp2 = pdu2.Data.ToObject(typeof(Execution)); if (temp2.State == Execution.ExecutionStates.FINISHED || temp2.State == Execution.ExecutionStates.TERMINATED) { PDU pdu3 = new PDU(){ MessageID = (int)CommandMessageID.ResetTS, MessageDescription = "Server please, reset TS", MessageType = "Command", Source = "Demo.Client", Data = new JObject() }; sendData(pdu3); } else { recieveData(); } }
/// <summary> /// Invoked when the socket listener accepts an incoming Bluetooth connection. /// </summary> /// <param name="sender">The socket listener that accepted the connection.</param> /// <param name="args">The connection accept parameters, which contain the connected socket.</param> private async void OnConnectionReceived( StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { // Don't need the listener anymore socketListener.Dispose(); socketListener = null; try { socket = args.Socket; } catch (Exception e) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser(e.Message, NotifyType.ErrorMessage); }); Disconnect(); return; } // Note - this is the supported way to get a Bluetooth device from a given socket var remoteDevice = await BluetoothDevice.FromHostNameAsync(socket.Information.RemoteHostName); writer = new DataWriter(socket.OutputStream); var reader = new DataReader(socket.InputStream); bool remoteDisconnection = false; await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Connected to Client: " + remoteDevice.Name, NotifyType.StatusMessage); }); // Infinite read buffer loop while (true) { try { // Based on the protocol we've defined, the first uint is the size of the message uint readLength = await reader.LoadAsync(sizeof(uint)); // Check if the size of the data is expected (otherwise the remote has already terminated the connection) if (readLength < sizeof(uint)) { remoteDisconnection = true; break; } uint currentLength = reader.ReadUInt32(); // Load the rest of the message since you already know the length of the data expected. readLength = await reader.LoadAsync(currentLength); // Check if the size of the data is expected (otherwise the remote has already terminated the connection) if (readLength < currentLength) { remoteDisconnection = true; break; } string message = reader.ReadString(currentLength); await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { ConversationListBox.Items.Add("Received: " + message); }); } // Catch exception HRESULT_FROM_WIN32(ERROR_OPERATION_ABORTED). catch (Exception ex) when ((uint)ex.HResult == 0x800703E3) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Client Disconnected Successfully", NotifyType.StatusMessage); }); break; } } reader.DetachStream(); if (remoteDisconnection) { Disconnect(); await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Client disconnected",NotifyType.StatusMessage); }); } }
public async static Task<Tuple<string, bool>> ReadFrom(string fpathname) { #if WINDOWS_PHONE return await Task.Run(() => { using (var storage = IsolatedStorageFile.GetUserStoreForApplication()) { if (!storage.FileExists(fpathname)) return new Tuple<string, bool>("", false); using (var fileStream = storage.OpenFile(fpathname, FileMode.Open)) { using (StreamReader sr = new StreamReader(fileStream)) { string data = sr.ReadToEnd(); return new Tuple<string, bool>(data, true); } } } }); #elif NETFX_CORE Tuple<string, bool> result = new Tuple<string, bool>("", false); StorageFile file = null; try { file = await ApplicationData.Current.LocalFolder.GetFileAsync(fpathname); if (file == null) return result; } catch (Exception) { return result; } using (var fs = await file.OpenAsync(FileAccessMode.Read)) { using (var inStream = fs.GetInputStreamAt(0)) { using (var reader = new DataReader(inStream)) { await reader.LoadAsync((uint)fs.Size); string data = reader.ReadString((uint)fs.Size); reader.DetachStream(); result = new Tuple<string, bool>(data, true); } } } return result; #else return await Task.Run (() => { try { string str = File.ReadAllText(fpathname); return new Tuple<string, bool>(str, true); } catch (Exception) { return new Tuple<string, bool>("", false); } }); #endif }
public override void Run() { #if WINRT StorageFile file = Package.Current.InstalledLocation.GetFileAsync(_path).AsTask().Result; using(var raStream = file.OpenReadAsync().AsTask().Result) { byte[] blob = new byte[CHUNK_SIZE]; while (IsRunning && raStream.CanRead) { DataReader reader = new DataReader(raStream.GetInputStreamAt(0)); reader.InputStreamOptions = InputStreamOptions.Partial; try { reader.LoadAsync((uint)blob.Length).AsTask().Wait(); int bytesRead = 0; while (reader.UnconsumedBufferLength > 0) { blob[bytesRead++] = reader.ReadByte(); } if (bytesRead > 0) { HandleData(blob, bytesRead); } } catch (Exception) { } finally { reader.DetachStream(); reader.Dispose(); } if (raStream.Position >= raStream.Size) { Terminate(); break; } Task.Delay(INTERVAL).Wait(); } } #else byte [] blob = new byte[CHUNK_SIZE]; while(IsRunning && _fileStream.CanRead) { int read = _fileStream.Read(blob, 0, CHUNK_SIZE); if( read > 0 ) { HandleData(blob, read); } if(_fileStream.CanSeek && _fileStream.Position >= _fileStream.Length) { Terminate(); break; } Thread.Sleep(INTERVAL); } #endif }
private async void OnForegroundSocketClicked(object sender, RoutedEventArgs e) { socket = new StreamSocket(); HostName host = new HostName("localhost"); try { await socket.ConnectAsync(host, "1983"); isConnected = true; while (isConnected) { try { DataReader reader; using (reader = new DataReader(socket.InputStream)) { // Set the DataReader to only wait for available data (so that we don't have to know the data size) reader.InputStreamOptions = InputStreamOptions.Partial; // The encoding and byte order need to match the settings of the writer we previously used. reader.UnicodeEncoding = UnicodeEncoding.Utf8; reader.ByteOrder = ByteOrder.LittleEndian; // Send the contents of the writer to the backing stream. // Get the size of the buffer that has not been read. await reader.LoadAsync(256); // Keep reading until we consume the complete stream. while (reader.UnconsumedBufferLength > 0) { string readString = reader.ReadString(reader.UnconsumedBufferLength); await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { messages.Add(readString); }); Debug.WriteLine(readString); await reader.LoadAsync(256); } reader.DetachStream(); } } catch (Exception exc) { MessageDialog dialog = new MessageDialog("Error reading the data"); await dialog.ShowAsync(); } } } catch (Exception exc) { MessageDialog dialog = new MessageDialog("Error connecting to the socket"); await dialog.ShowAsync(); } }
async private void recieveData() { StreamSocketListener listener = new StreamSocketListener(); DataReader dr = new DataReader(socket.InputStream); dr.InputStreamOptions = InputStreamOptions.Partial; string msg = null; var count = await dr.LoadAsync(8192); if (count > 0) msg = dr.ReadString(count); dr.DetachStream(); dr.Dispose(); try { pdu2 = new PDU(msg); ListOfProcedures temp = pdu2.Data.ToObject(typeof(ListOfProcedures)); foreach (Procedure pro in temp.ProcedureList) { _kakecollection.Add(pro); } } catch (Exception e) { recievedMessage.Text = "Failed to cast incomming message to usable type: PDU"; } }
async private void ReadButton_Click(object sender, RoutedEventArgs e) { if (EventHandlerForDevice.Current.IsDeviceConnected) { try { rootPage.NotifyUser("Reading...", NotifyType.StatusMessage); // We need to set this to true so that the buttons can be updated to disable the read button. We will not be able to // update the button states until after the read completes. IsReadTaskPending = true; DataReaderObject = new DataReader(EventHandlerForDevice.Current.Device.InputStream); UpdateReadButtonStates(); await ReadAsync(ReadCancellationTokenSource.Token); } catch (OperationCanceledException /*exception*/) { NotifyReadTaskCanceled(); } catch (Exception exception) { MainPage.Current.NotifyUser(exception.Message.ToString(), NotifyType.ErrorMessage); Debug.WriteLine(exception.Message.ToString()); } finally { IsReadTaskPending = false; DataReaderObject.DetachStream(); DataReaderObject = null; UpdateReadButtonStates(); } } else { Utilities.NotifyDeviceNotConnected(); } }
private static async Task<string> Receive(StreamSocket socket) { string result = null; if (socket != null) using (var reader = new DataReader(socket.InputStream)) { reader.InputStreamOptions = InputStreamOptions.Partial; uint sizeFieldLength = await reader.LoadAsync(sizeof(uint)); if (sizeFieldLength == sizeof(uint)) { uint dataLength = reader.ReadUInt32(); uint actualDataLength = await reader.LoadAsync(dataLength); if (dataLength == actualDataLength) result = reader.ReadString(actualDataLength); } reader.DetachStream(); } return result; }
private static async Task<string> GetReceiptAsync(string productId) { var encryptedFilename = CipherEncryption(productId); var encodedFileName = Convert.ToBase64String(encryptedFilename.ToArray()); var encodedAndEscapedFilename = encodedFileName.Replace('/', '-'); //var folder = ApplicationData.Current.RoamingFolder; var folder = ApplicationData.Current.RoamingFolder; if (folder == null) return "NoReceipt"; folder = await folder.CreateFolderAsync("Receipts", CreationCollisionOption.OpenIfExists); try { var file = await folder.GetFileAsync(encodedAndEscapedFilename + ".pmd"); var stream = await file.OpenAsync(FileAccessMode.Read); var dataReader = new DataReader(stream.GetInputStreamAt(0)); uint u = await dataReader.LoadAsync((uint)stream.Size); IBuffer buffEncrypted = dataReader.ReadBuffer(u); dataReader.DetachStream(); stream.Dispose(); stream = null; var receipt = CipherDecryption(buffEncrypted); if (productId.Contains("subscritpion") && DownloadManager.ReceiptExpired(receipt)) { await file.DeleteAsync(StorageDeleteOption.PermanentDelete); return "NoReceipt"; } return receipt; } catch (Exception) { return "NoReceipt"; } }
/// <summary> /// Read the input stream of the data socket. /// </summary> /// <returns>FtpResponse containing what has been on the socket.</returns> private async Task<FtpFileResponse> ReadSocketFileDataReceiver() { try { DataReader inputStream = new DataReader(socketDataReceiver.InputStream); inputStream.InputStreamOptions = InputStreamOptions.Partial; DataReaderLoadOperation loadOperation = inputStream.LoadAsync(2500); await loadOperation; if (loadOperation.Status != AsyncStatus.Completed) { return new FtpFileResponse(loadOperation.Status.ToString(), null); } //read complete message uint byteCount = inputStream.UnconsumedBufferLength; byte[] bytes = new byte[byteCount]; inputStream.ReadBytes(bytes); FtpFileResponse lResponse = new FtpFileResponse(FtpConstants.CODE_TRANSFER_COMPLETE, bytes); //detach stream so that it won't be closed when the datareader is disposed later inputStream.DetachStream(); return lResponse; } catch (Exception e) { return new FtpFileResponse(Convert.ToString(e.HResult), null); } }
private static async Task<byte[]> ReadBytesAsync(StorageFile file) { using (var fs = await file.OpenAsync(FileAccessMode.Read)) { using (var inStream = fs.GetInputStreamAt(0)) { using (var dataReader = new DataReader(inStream)) { await dataReader.LoadAsync((uint)fs.Size); var data = new byte[dataReader.UnconsumedBufferLength]; dataReader.ReadBytes(data); dataReader.DetachStream(); return data; } } } }
public async Task LoadCookiesAsync(Guid requestId) { string data = null; var cookieContainer = new CookieContainer(); var file = await ApplicationData.Current.LocalFolder.CreateFileAsync(CookieCacheFile, CreationCollisionOption.OpenIfExists); using (var fs = await file.OpenAsync(FileAccessMode.Read)) { using (var inStream = fs.GetInputStreamAt(0)) { using (var dataReader = new DataReader(inStream)) { await dataReader.LoadAsync((uint)fs.Size); data = dataReader.ReadString((uint)fs.Size); dataReader.DetachStream(); var cookies = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, Cookie>>>(data); if (cookies != null) { foreach (var cookieSet in cookies) { foreach (var cookie in cookieSet.Value) { cookieContainer.Add(new Uri(cookie.Key), cookie.Value); } } } this.knownCookies = cookieContainer; this.persistentCookies = cookies ?? new Dictionary<string, Dictionary<string, Cookie>>(); } } } Trace.Verbose(requestId, "Loaded {0} cookies: {1}\r\n", cookieContainer.Count, data); }
public async Task<string> Recv() { string headerBuffer = ""; try { DataReader socketDataReader = new DataReader(internalSocket.InputStream); while (!headerBuffer.EndsWith("MLEN") && headerBuffer.Length < MAX_HEADER_LENGTH) { await socketDataReader.LoadAsync(1).AsTask(getTimeoutToken()); headerBuffer += socketDataReader.ReadString(1); } if (!headerBuffer.EndsWith("MLEN")) { return null; } UInt64 length; if (!UInt64.TryParse(headerBuffer.Replace("MLEN", ""), out length)) { return null; } byte[] data = new byte[length]; ulong dataReceived = 0; while (dataReceived < length) { int currentChunkSize = CHUNK_SIZE; if (length - dataReceived < CHUNK_SIZE) currentChunkSize = (int)(length - dataReceived); byte[] chunk = new byte[currentChunkSize]; await socketDataReader.LoadAsync((uint)currentChunkSize).AsTask(getTimeoutToken()); socketDataReader.ReadBytes(chunk); Array.Copy(chunk, 0, data, (int)dataReceived, currentChunkSize); dataReceived += (ulong)currentChunkSize; repportProgress((int)dataReceived, (int)length); } socketDataReader.DetachStream(); return Cryptography.TextManipulation.DecodeUTF(data); } catch (Exception error) { throw new NetworkingError(error.Message); } }
public async void Send(byte[] fileBytes) { try { if (Speakers != null && Speakers.Count > 0 && fileBytes != null) { //iterate through the speakers and send out the media file to each speaker foreach (Speaker speaker in Speakers) { StreamSocket socket = speaker.Socket; if (socket != null) { IOutputStream outStream = socket.OutputStream; using (DataWriter dataWriter = new DataWriter(outStream)) { //write header bytes to indicate to the subscriber //information about the file to be sent dataWriter.WriteInt16((short)MessageType.Media); dataWriter.WriteInt32(fileBytes.Length); await dataWriter.StoreAsync(); //start from 0 and increase by packet size int partNumber = 0; int sourceIndex = 0; int bytesToWrite = fileBytes.Length; while (bytesToWrite > 0) { dataWriter.WriteInt32(partNumber); int packetSize = bytesToWrite; if (packetSize > MAX_PACKET_SIZE) { packetSize = MAX_PACKET_SIZE; } byte[] fragmentedPixels = new byte[packetSize]; Array.Copy(fileBytes, sourceIndex, fragmentedPixels, 0, packetSize); dataWriter.WriteBytes(fragmentedPixels); Debug.WriteLine("sent byte packet length " + packetSize); await dataWriter.StoreAsync(); sourceIndex += packetSize; bytesToWrite -= packetSize; partNumber++; Debug.WriteLine("sent total bytes " + (fileBytes.Length - bytesToWrite)); } //Finally DetachStream dataWriter.DetachStream(); } } } //check the speakers have all received the file foreach (Speaker speaker in Speakers) { StreamSocket socket = speaker.Socket; if (socket != null) { //wait for the 'I got it' message DataReader reader = new DataReader(socket.InputStream); uint x = await reader.LoadAsync(sizeof(short)); MessageType t = (MessageType)reader.ReadInt16(); if (MessageType.Ready == t) { await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Speakers.Remove(speaker); speaker.Status = "Ready"; Speakers.Add(speaker); }); } reader.DetachStream(); } } } } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } }
private async Task<string> Receive() { if (socket == null) return null; using (DataReader reader = new DataReader(socket.InputStream)) { // reader.InputStreamOptions = InputStreamOptions.Partial; reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; reader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; try { while (true) { StringBuilder ImageStrBuilder = new StringBuilder(); // Set the DataReader to only wait for available data (so that we don't have to know the data size) // reader.InputStreamOptions = Windows.Storage.Streams.InputStreamOptions.Partial; // The encoding and byte order need to match the settings of the writer we previously used. // Send the contents of the writer to the backing stream. // Get the size of the buffer that has not been read. // await Task.Delay(50); // if (socket == null) return null; uint sizeFieldCount = await reader.LoadAsync(sizeof(uint)); if (sizeFieldCount != sizeof(uint)) { // The underlying socket was closed before we were able to read the whole data. return null; } uint stringLength = reader.ReadUInt32(); uint actualStringLength = await reader.LoadAsync(stringLength); if (stringLength != actualStringLength) { // The underlying socket was closed before we were able to read the whole data. return null; } // Keep reading until we consume the complete stream. // while (reader.UnconsumedBufferLength > 0) // { // ImageStrBuilder.Append(reader.ReadString(reader.UnconsumedBufferLength)); // await reader.LoadAsync(2048); // } // ImageString = ImageStrBuilder.ToString(); // else if (ImageStrBuilder.Length < 100 && ImageStrBuilder.Length > 0) // { // Calculate(ImageString); // } // ClientAddLine("Received(" + DateTime.Now.ToString("h:mm:ss") + "): " + ImageStrBuilder.ToString()); //await Task.Factory.StartNew(ReloadPicture); // Send(2); ImageStrBuilder.Append(reader.ReadString(actualStringLength)); // reader.DetachBuffer(); reader.DetachStream(); // reader.Dispose(); return ImageStrBuilder.ToString(); // return "error"; } } catch (Exception e) { // ClientWaitForMessage(); //received = false; return "error"; } } }
private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { Debug.WriteLine("Connection Received on Port {0}", sender.Information.LocalPort); StreamSocket streamSocket = args.Socket; if (streamSocket != null) { DataReader reader = new DataReader(streamSocket.InputStream); try { // Read first 4 bytes (length of the subsequent string). uint sizeFieldCount = await reader.LoadAsync(sizeof(uint)); if (sizeFieldCount != sizeof(uint)) { // The underlying socket was closed before we were able to read the whole data. return; } // Read the length of the 'packet'. uint length = reader.ReadUInt32(); uint actualLength = await reader.LoadAsync(length); if (length != actualLength) { // The underlying socket was closed before we were able to read the whole data. return; } string name = reader.ReadString(actualLength); Speaker speaker = new Speaker() { Name = name, Address = streamSocket.Information.RemoteAddress.DisplayName, Status = "Connected", Socket = streamSocket }; await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Speakers.Add(speaker); }); reader.DetachStream(); Debug.WriteLine("New speaker added " + name); } catch (Exception e) { Debug.WriteLine("Error in connection received: " + e); } } }
/// <summary> /// Invoked when the socket listener accepted an incoming Bluetooth connection. /// </summary> /// <param name="sender">The socket listener that accecpted the connection.</param> /// <param name="args">The connection accept parameters, which contain the connected socket.</param> private async void OnConnectionReceived( StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { try { NotifyStatus("Client Connected"); // Don't need the listener anymore socketListener.Dispose(); socketListener = null; socket = args.Socket; writer = new DataWriter(socket.OutputStream); var reader = new DataReader(socket.InputStream); bool remoteDisconnection = false; while (true) { uint readLength = await reader.LoadAsync(sizeof(uint)); if (readLength < sizeof(uint)) { remoteDisconnection = true; break; } uint currentLength = reader.ReadUInt32(); readLength = await reader.LoadAsync(currentLength); if (readLength < currentLength) { remoteDisconnection = true; break; } string message = reader.ReadString(currentLength); await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { ConversationListBox.Items.Add("Received: " + message); }); } reader.DetachStream(); if (remoteDisconnection) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { Disconnect(); NotifyStatus("Client disconnected."); }); } } catch (Exception e) { NotifyError(e); } }
private async Task<UInt32> serialReadAsync(uint read_size) { try { if (serialPort == null) { printLog("No port selected"); return 0; } //TODO handle cancelationTokens using (DataReader dataReaderObject = new DataReader(serialPort.InputStream)) { // Launch the task and wait UInt32 bytesRead = await dataReaderObject.LoadAsync(read_size); for (int i = 0; i < bytesRead; i++) { serialReceive[i] = dataReaderObject.ReadByte(); } dataReaderObject.DetachStream(); return bytesRead; } } catch (Exception ex) { printLog(ex.Message); return 0; } }